Compare commits

..
Author SHA1 Message Date
Jason Mitchell 956f9e344e Update the tesselator checks to allow for non main instance tesselators while still on the main thread (#106) 2023-12-30 13:00:59 -08:00
Darren Eberly acc1f58778 Round texture coordinates instead of truncating (#105)
Backported fix from embeddium: https://github.com/embeddedt/embeddium/commit/a82950cf8e77ce78d9c3dacbfa509900f3a224ca
2023-12-30 12:25:33 -08:00
Caedis 1a38bd1a00 Move mod checks to their own static class (#103) 2023-12-30 13:21:58 -06:00
Jason Mitchell cfc19bb35e Repo cleanup
* Remove (currently) unused covers maven
* Limit FP maven to com.falsepattern to limit requests going that way
2023-12-30 10:51:54 -08:00
mist475 446c8e74ee replace lotr blockrendering hashmap with concurrent version (#98) 2023-12-30 10:39:34 -08:00
FalsePatternandDarren Eberly 74cdc561e6 Preliminary ChunkAPI/EndlessIDs compatibility (#94)
* Preliminary ChunkAPI compatibility
* endlessids biome array crash fix
* Ensure skylight array is not null when hasSky is set

---------

Co-authored-by: Darren Eberly <[email protected]>
2023-12-30 10:26:03 -08:00
Caedis 67fbcc8ff0 Add debug logging option (#97)
* add debug logging option

* remove the deobf check
2023-12-29 01:54:58 -06:00
Jason Mitchell d19b8d5302 Handle bad matrix modes (#93)
* Handle common incorrect modes for glMatrixMode
* Handle matrix stack over/under flow
2023-12-28 21:05:11 -05:00
embeddedt ae0e03bead Do not include transformed mods in runtime classpath by default (#91) 2023-12-28 21:23:40 +00:00
embeddedt 7d7d73a48f Fix constant pool parser early-exiting instead of checking all strings (#90)
Use a helper variable instead of the label-break pattern, the latter
is ugly and error-prone, in my opinion
2023-12-28 13:21:00 -08:00
Jason Mitchell 6dcc4649db Update Hodgepodge required version 2023-12-28 09:42:38 -08:00
Jason Mitchell 5db5c7f683 Update README.MD 2023-12-28 09:36:51 -08:00
Jason Mitchellandembeddedt 21b9b8cb3f Dynamic cstPoolParser (#89)
* Dynamic cats... err cstPoolParser
* Prevent block classes that redeclare vanilla fields from being redirected
* Obviously blocks don't shadow their own fields

---------

Co-authored-by: embeddedt <[email protected]>
2023-12-28 09:08:49 -08:00
Jason Mitchell fc520de642 Dirty no more 2023-12-28 08:20:08 -08:00
Jason Mitchell 9916075569 Catch the specific error, rather than generic Exception (which the error doesn't seem to subclass anyway) (#88) 2023-12-28 08:15:50 -08:00
Jason Mitchell 6624a9adb3 Fully track GL State changes (#83)
* Fully track GL State changes
* Now compatible with glPushAttrib, and glPopAttrib
* Cache mask -> features using an Int2ObjectMap
2023-12-28 07:55:16 -08:00
Jason Mitchell c3216007c1 Add missed IC2 mixin 2023-12-28 07:42:27 -08:00
Jason Mitchell 92b22b1827 No shader issues for now 2023-12-28 06:27:28 -08:00
embeddedt f32c14f795 Add missing import 2023-12-27 12:05:47 -08:00
embeddedt ef15577b15 Fix Block bounds fields redirects not applying to subclasses 2023-12-27 12:05:47 -08:00
embeddedt ac60c01788 Delete vanilla block bounds fields 2023-12-27 09:06:16 -08:00
Caedis 9410902937 Add FalseTweaks and SmoothFont to temp incompatibilities (#70)
* Update README.MD

Add FalseTweaks to temp incompatibilities

* and add SmoothFont
2023-12-27 03:59:27 -06:00
Jason Mitchell 52776530d8 Handle GL_COMPILE separately from GL_COMPILE_AND_EXECUTE
* Should fix OpenComputer issues
2023-12-26 17:19:35 -08:00
Jason Mitchell 9cebb352ad Opt in debug
* Less stutter with buggy stuff
2023-12-26 15:12:44 -08:00
embeddedt d810eaf876 Use client world for main thread renders 2023-12-26 12:45:45 -08:00
Jason Mitchell 1a1ca32721 Update 000-report-bug.yml 2023-12-26 09:10:00 -08:00
Jason Mitchell a3d689e806 Because of course someone uses DoubleBuffer 2023-12-26 08:45:26 -08:00
embeddedt d4e22b6c0c Avoid restoring GL buffers we didn't modify 2023-12-26 07:35:29 -08:00
Jason Mitchell 7e24f6a395 Reduce stuttering on Nvidia - Track the model view and projection matrix (#56)
* Track the model view and projection matrix
* Cache ViewportState as well
* Add mixin to speedup Jabba's saveBoundTexture
2023-12-25 20:16:43 -08:00
embeddedt c8e6a6f34f Make glPushAttrib match native behavior if bypassing state manager cache 2023-12-25 17:19:59 -08:00
Jason Mitchell f7a79cf02f Switch up how we're grabbing the projection & model view matrix to avoid needing to call glGetFloat() again 2023-12-25 16:14:35 -08:00
74 changed files with 1747 additions and 334 deletions

No files matched your search

+6 -4
View File
@@ -45,9 +45,9 @@ body:
- type: textarea
id: modlist
attributes:
label: Mod List
description: "List of mods, ideally a minimal reproducible set (can be retrieved from latest.log)"
placeholder: "List of mods go here"
label: Mod List or GTNH Pack Version
description: "List of mods, ideally a minimal reproducible set (can be retrieved from latest.log). If using GTNH please indicate pack version and any changed mods, not the entire modlist."
placeholder: "List of mods or GTNH Pack version goes here"
validations:
required: true
- type: checkboxes
@@ -60,4 +60,6 @@ body:
required: true
- label: "I have read the known incompatibilities and this is not related to one of those."
required: true
- label: "This issue is not shader related (they aren't ready yet for testing)"
required: true
+4 -1
View File
@@ -9,6 +9,8 @@
* Forge Relocation - Currently non Thread Safe; safe if not in use
* ProjectRed Frames - Currently non Thread Safe; safe if not in use
* EndlessIDs - Future compat planned
* FalseTweaks - Future compat planned
* SmoothFont - Future compat planned
* RPLE - Future compat planned
# Permanent Incompatibilities
@@ -16,8 +18,9 @@
* Fastcraft [Disable, won't fix]
* LWJGL3ify 1.5.4 and below - Use the latest version available, 1.5.7+
* ArchaicFix 0.6.2 and below - Use 0.7.0 or above
* Hodgepodge 2.4.2 and below - Use 2.4.3 or above
* Hodgepodge 2.4.3 and below - Use 2.4.4 or above
* CodeChickenCore/Lib <1.2.0 - Threading issues, use 1.2.0+
* Neodymium - Untested, but unlikely to be compatible. (Chunk Meshing is definitely incompatible, other features might work depending on config)
# Credits
* ShadersMod
+1 -1
View File
@@ -798,7 +798,7 @@ dependencies {
java17Dependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}")
}
if (modId != 'hodgepodge') {
java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.4.3')
java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.4.4')
}
java17PatchDependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}:forgePatches") {transitive = false}
+19 -1
View File
@@ -33,9 +33,23 @@
*
* For more details, see https://docs.gradle.org/8.0.1/userguide/java_library_plugin.html#sec:java_library_configurations_graph
*/
configurations {
transformedMod // Mods that can be transformed - used for compiling angelica, but not necessary at runtime
transformedMod.canBeConsumed = false
transformedModCompileOnly
transformedModCompileOnly.canBeConsumed = false
// Add the transformed mod dependencies to the compilation classpaths, but don't publish them in the Maven metadata
compileClasspath.extendsFrom(transformedMod, transformedModCompileOnly)
testCompileClasspath.extendsFrom(transformedMod, transformedModCompileOnly)
// Can be enabled for testing if desired
// runtimeClasspath.extendsFrom(transformedMod)
// testRuntimeClasspath.extendsFrom(transformedMod)
}
dependencies {
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.4.3")
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.4.4")
compileOnly("org.projectlombok:lombok:1.18.22") {transitive = false }
annotationProcessor("org.projectlombok:lombok:1.18.22")
@@ -61,6 +75,8 @@ dependencies {
compileOnly("com.github.GTNewHorizons:twilightforest:2.5.1:dev") {transitive = false }
compileOnly(rfg.deobf('curse.maven:witchery-69673:2234410'))
compileOnly("com.falsepattern:chunkapi-mc1.7.10:0.5.0:api")
compileOnly("com.falsepattern:endlessids-mc1.7.10:1.5-beta0002:dev")
compileOnly(rfg.deobf("curse.maven:extrautils-225561:2264383"))
compileOnly(rfg.deobf("curse.maven:dynamiclights-227874:2337326"))
@@ -74,4 +90,6 @@ dependencies {
runtimeOnly(deobf("https://github.com/makamys/CoreTweaks/releases/download/0.3.3.2/CoreTweaks-1.7.10-0.3.3.2+nomixin.jar"))
// Hodgepodge
transformedMod("net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev")
}
+4 -5
View File
@@ -2,11 +2,10 @@
repositories {
maven {
name = 'covers1624 maven'
url = 'https://nexus.covers1624.net/repository/maven-hosted/'
metadataSources {
mavenPom()
artifact()
name = 'mavenpattern'
url = 'https://mvn.falsepattern.com/releases'
content {
includeGroup "com.falsepattern"
}
}
mavenLocal()
@@ -1,9 +1,9 @@
package com.gtnewhorizons.angelica;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.proxy.CommonProxy;
import com.gtnewhorizons.angelica.utils.AnimationMode;
import com.gtnewhorizons.angelica.utils.ManagedEnum;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
@@ -14,24 +14,20 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
modid = "angelica",
name = "Angelica",
version = Tags.VERSION,
dependencies = " before:lwjgl3ify@[1.5.3,);" + " after:hodgepodge@[2.4.3,);" + " after:CodeChickenCore@[1.2.0,);",
dependencies = " before:lwjgl3ify@[1.5.3,);" + " after:hodgepodge@[2.4.4,);" + " after:CodeChickenCore@[1.2.0,);",
acceptedMinecraftVersions = "[1.7.10]",
acceptableRemoteVersions = "*")
public class AngelicaMod {
@SidedProxy(clientSide = "com.gtnewhorizons.angelica.proxy.ClientProxy", serverSide = "com.gtnewhorizons.angelica.proxy.CommonProxy")
public static CommonProxy proxy;
/** Mixin Version */
public static boolean isNEIDLoaded;
/** ASM Version */
public static boolean isOldNEIDLoaded;
public static final boolean lwjglDebug = Boolean.parseBoolean(System.getProperty("org.lwjgl.util.Debug", "false"));
public static final ManagedEnum<AnimationMode> animationsMode = new ManagedEnum<>(AnimationMode.VISIBLE_ONLY);
@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {
isNEIDLoaded = Loader.isModLoaded("neid");
isOldNEIDLoaded = Loader.isModLoaded("notenoughIDs");
ModStatus.preInit();
proxy.preInit(event);
}
@@ -1,9 +1,11 @@
package com.gtnewhorizons.angelica.compat;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.falsepattern.chunk.api.DataRegistry;
import com.gtnewhorizons.angelica.mixins.early.sodium.MixinExtendedBlockStorage;
import com.gtnewhorizons.angelica.mixins.interfaces.ExtendedNibbleArray;
import com.gtnewhorizons.neid.mixins.interfaces.IExtendedBlockStorageMixin;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.NibbleArray;
import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
import ru.fewizz.idextender.Hooks;
@@ -16,44 +18,51 @@ public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
this.hasSky = hasSky;
}
public ExtendedBlockStorageExt(ExtendedBlockStorage storage) {
public ExtendedBlockStorageExt(Chunk chunk, ExtendedBlockStorage storage) {
super(((MixinExtendedBlockStorage) storage).getYBase(), storage.getSkylightArray() != null);
int arrayLen;
if (AngelicaMod.isNEIDLoaded){
final short[] block16BArray = ((IExtendedBlockStorageMixin)(Object)this).getBlock16BArray();
System.arraycopy(((IExtendedBlockStorageMixin)(Object)storage).getBlock16BArray(), 0, block16BArray, 0, block16BArray.length);
if(storage.getBlockMSBArray() != null) {
this.setBlockMSBArray(new NibbleArray(block16BArray.length, 4));
copyNibbleArray((ExtendedNibbleArray) storage.getBlockMSBArray(), (ExtendedNibbleArray) this.getBlockMSBArray());
if (ModStatus.isChunkAPILoaded) {
if (storage.getSkylightArray() != null) {
hasSky = true;
}
arrayLen = block16BArray.length;
}
else if (AngelicaMod.isOldNEIDLoaded){
final short[] blockLSBArray = Hooks.get(this);
System.arraycopy(Hooks.get(storage), 0, blockLSBArray, 0, blockLSBArray.length);
// getBlockMSBArray is nuked in asm version
arrayLen = blockLSBArray.length;
}
else {
final byte[] blockLSBArray = this.getBlockLSBArray();
System.arraycopy(storage.getBlockLSBArray(), 0, blockLSBArray, 0, blockLSBArray.length);
if(storage.getBlockMSBArray() != null) {
this.setBlockMSBArray(new NibbleArray(blockLSBArray.length, 4));
copyNibbleArray((ExtendedNibbleArray) storage.getBlockMSBArray(), (ExtendedNibbleArray) this.getBlockMSBArray());
DataRegistry.cloneSubChunk(chunk, storage, this);
} else {
int arrayLen;
if (ModStatus.isNEIDLoaded){
final short[] block16BArray = ((IExtendedBlockStorageMixin)(Object)this).getBlock16BArray();
System.arraycopy(((IExtendedBlockStorageMixin)(Object)storage).getBlock16BArray(), 0, block16BArray, 0, block16BArray.length);
if(storage.getBlockMSBArray() != null) {
this.setBlockMSBArray(new NibbleArray(block16BArray.length, 4));
copyNibbleArray((ExtendedNibbleArray) storage.getBlockMSBArray(), (ExtendedNibbleArray) this.getBlockMSBArray());
}
arrayLen = block16BArray.length;
}
else if (ModStatus.isOldNEIDLoaded){
final short[] blockLSBArray = Hooks.get(this);
System.arraycopy(Hooks.get(storage), 0, blockLSBArray, 0, blockLSBArray.length);
// getBlockMSBArray is nuked in asm version
arrayLen = blockLSBArray.length;
}
else {
final byte[] blockLSBArray = this.getBlockLSBArray();
System.arraycopy(storage.getBlockLSBArray(), 0, blockLSBArray, 0, blockLSBArray.length);
if(storage.getBlockMSBArray() != null) {
this.setBlockMSBArray(new NibbleArray(blockLSBArray.length, 4));
copyNibbleArray((ExtendedNibbleArray) storage.getBlockMSBArray(), (ExtendedNibbleArray) this.getBlockMSBArray());
}
arrayLen = blockLSBArray.length;
}
arrayLen = blockLSBArray.length;
}
copyNibbleArray((ExtendedNibbleArray) storage.getMetadataArray(), (ExtendedNibbleArray)this.getMetadataArray());
copyNibbleArray((ExtendedNibbleArray) storage.getBlocklightArray(), (ExtendedNibbleArray)this.getBlocklightArray());
if(storage.getSkylightArray() != null) {
hasSky = true;
if(this.getSkylightArray() == null) {
this.setSkylightArray(new NibbleArray(arrayLen, 4));
copyNibbleArray((ExtendedNibbleArray) storage.getMetadataArray(), (ExtendedNibbleArray)this.getMetadataArray());
copyNibbleArray((ExtendedNibbleArray) storage.getBlocklightArray(), (ExtendedNibbleArray)this.getBlocklightArray());
if(storage.getSkylightArray() != null) {
hasSky = true;
if(this.getSkylightArray() == null) {
this.setSkylightArray(new NibbleArray(arrayLen, 4));
}
copyNibbleArray((ExtendedNibbleArray) storage.getSkylightArray(), (ExtendedNibbleArray) this.getSkylightArray());
}
copyNibbleArray((ExtendedNibbleArray) storage.getSkylightArray(), (ExtendedNibbleArray) this.getSkylightArray());
}
((MixinExtendedBlockStorage) this).setBlockRefCount(((MixinExtendedBlockStorage) storage).getBlockRefCount());
}
@@ -0,0 +1,25 @@
package com.gtnewhorizons.angelica.compat;
import cpw.mods.fml.common.Loader;
public class ModStatus {
/**
* Mixin Version
*/
public static boolean isNEIDLoaded;
/**
* ASM Version
*/
public static boolean isOldNEIDLoaded;
public static boolean isLotrLoaded;
public static boolean isChunkAPILoaded;
public static boolean isEIDBiomeLoaded;
public static void preInit(){
isNEIDLoaded = Loader.isModLoaded("neid");
isOldNEIDLoaded = Loader.isModLoaded("notenoughIDs");
isLotrLoaded = Loader.isModLoaded("lotr");
isChunkAPILoaded = Loader.isModLoaded("chunkapi");
isEIDBiomeLoaded = Loader.isModLoaded("endlessids_biome");
}
}
@@ -73,4 +73,19 @@ public class AngelicaConfig {
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean optimizeTextureLoading;
@Config.Comment("Optimize slow glGetInteger in Jabba w/ Nvidia Drivers")
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean optimizeJabbaGetInteger;
@Config.Comment("Fix thread-safety in lotrs rendering")
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean fixLotrSodiumCompat;
@Config.Comment("Enable Debug Logging")
@Config.DefaultBoolean(false)
@Config.RequiresMcRestart
public static boolean enableDebugLogging;
}
@@ -0,0 +1,258 @@
package com.gtnewhorizons.angelica.glsm;
import com.google.common.collect.ImmutableSet;
import com.gtnewhorizons.angelica.glsm.stacks.IStateStack;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL13;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class Feature {
private static final int[] supportedAttribs = new int[] { GL11.GL_ACCUM_BUFFER_BIT, GL11.GL_COLOR_BUFFER_BIT, GL11.GL_CURRENT_BIT, GL11.GL_DEPTH_BUFFER_BIT,
GL11.GL_ENABLE_BIT, GL11.GL_EVAL_BIT, GL11.GL_FOG_BIT, GL11.GL_HINT_BIT, GL11.GL_LIGHTING_BIT, GL11.GL_LINE_BIT, GL11.GL_LIST_BIT,
GL13.GL_MULTISAMPLE_BIT, GL11.GL_PIXEL_MODE_BIT, GL11.GL_POINT_BIT, GL11.GL_POLYGON_BIT, GL11.GL_POLYGON_STIPPLE_BIT, GL11.GL_SCISSOR_BIT,
GL11.GL_STENCIL_BUFFER_BIT, GL11.GL_TEXTURE_BIT, GL11.GL_TRANSFORM_BIT, GL11.GL_VIEWPORT_BIT };
static final Int2ObjectMap<Set<IStateStack<?>>> maskToFeaturesMap = new Int2ObjectOpenHashMap<>();
static Set<IStateStack<?>> maskToFeatures(int mask) {
if(maskToFeaturesMap.containsKey(mask)) {
return maskToFeaturesMap.get(mask);
}
final Set<IStateStack<?>> features = new HashSet<>();
for(int attrib : Feature.supportedAttribs) {
if((mask & attrib) == attrib) {
features.addAll(getFeatures(attrib));
}
}
maskToFeaturesMap.put(mask, features);
return features;
}
private static final Map<Integer, Set<IStateStack<?>>> attribToFeatures = new HashMap<>();
static {
attribToFeatures.put(GL11.GL_COLOR_BUFFER_BIT, ImmutableSet.of(
GLStateManager.alphaTest // GL_ALPHA_TEST enable bit
, GLStateManager.alphaState // Alpha test function and reference value
, GLStateManager.blendMode // GL_BLEND enable bit
, GLStateManager.blendState // Blending source and destination functions
// Constant blend color
// Blending equation
// GL_DITHER enable bit
// GL_DRAW_BUFFER setting
// GL_COLOR_LOGIC_OP enable bit
// GL_INDEX_LOGIC_OP enable bit
// Logic op function
, GLStateManager.colorMask // Color mode and index mode writemasks
, GLStateManager.color // Color mode and index mode writemasks
, GLStateManager.clearColor // Color mode and index mode clear values
));
attribToFeatures.put(GL11.GL_CURRENT_BIT, ImmutableSet.of(
// Current RGBA color
// Current color index
// Current normal vector
// Current texture coordinates
// Current raster position
// GL_CURRENT_RASTER_POSITION_VALID flag
// RGBA color associated with current raster position
// Color index associated with current raster position
// Texture coordinates associated with current raster position
// GL_EDGE_FLAG flag
));
attribToFeatures.put(GL11.GL_DEPTH_BUFFER_BIT, ImmutableSet.of(
GLStateManager.depthTest // GL_DEPTH_TEST enable bit
, GLStateManager.depthState // Depth buffer test function
// Depth buffer clear value
// GL_DEPTH_WRITEMASK enable bit
));
final HashSet<IStateStack<?>> enableBits = new HashSet<>(ImmutableSet.of(
GLStateManager.alphaTest // GL_ALPHA_TEST flag
// GL_AUTO_NORMAL flag
, GLStateManager.blendMode // GL_BLEND flag
// Enable bits for the user-definable clipping planes
// GL_COLOR_MATERIAL
, GLStateManager.cullState // GL_CULL_FACE flag
, GLStateManager.depthTest // GL_DEPTH_TEST flag
// GL_DITHER flag
, GLStateManager.fogMode // GL_FOG flag
// GL_LIGHTi where 0 <= i < GL_MAX_LIGHTS
// GL_LIGHTING flag
// GL_LINE_SMOOTH flag
// GL_LINE_STIPPLE flag
// GL_INDEX_LOGIC_OP flag
// GL_COLOR_LOGIC_OP flag
// GL_MAP1_x where x is a map type
// GL_MAP2_x where x is a map type
// GL_MULTISAMPLE flag
// GL_NORMALIZE flag
// GL_POINT_SMOOTH flag
// GL_POLYGON_OFFSET_LINE flag
// GL_POLYGON_OFFSET_FILL flag
// GL_POLYGON_OFFSET_POINT flag
// GL_POLYGON_SMOOTH flag
// GL_POLYGON_STIPPLE flag
// GL_SAMPLE_ALPHA_TO_COVERAGE flag
// GL_SAMPLE_ALPHA_TO_ONE flag
// GL_SAMPLE_COVERAGE flag
// GL_SCISSOR_TEST flag
// GL_STENCIL_TEST flag
// GL_TEXTURE_1D flag
// GL_TEXTURE_2D flag - Below
// GL_TEXTURE_3D flag
// Flags GL_TEXTURE_GEN_x where x is S, T, R, or Q
));
// GL_TEXTURE_2D flag
for(int i = 0 ; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
enableBits.add(GLStateManager.textures.getTextureUnitStates(i));
}
attribToFeatures.put(GL11.GL_ENABLE_BIT, enableBits);
attribToFeatures.put(GL11.GL_EVAL_BIT, ImmutableSet.of(
// GL_MAP1_x enable bits, where x is a map type
// GL_MAP2_x enable bits, where x is a map type
// 1D grid endpoints and divisions
// 2D grid endpoints and divisions
// GL_AUTO_NORMAL enable bit
));
attribToFeatures.put(GL11.GL_FOG_BIT, ImmutableSet.of(
GLStateManager.fogMode // GL_FOG enable bit
, GLStateManager.fogState // Fog color
// ^^ Fog density
// ^^ Linear fog start
// ^^ Linear fog end
// Fog index
// ^^ GL_FOG_MODE value
));
attribToFeatures.put(GL11.GL_HINT_BIT, ImmutableSet.of(
// GL_PERSPECTIVE_CORRECTION_HINT setting
// GL_POINT_SMOOTH_HINT setting
// GL_LINE_SMOOTH_HINT setting
// GL_POLYGON_SMOOTH_HINT setting
// GL_FOG_HINT setting
// GL_GENERATE_MIPMAP_HINT setting
// GL_TEXTURE_COMPRESSION_HINT setting
));
attribToFeatures.put(GL11.GL_LIGHTING_BIT, ImmutableSet.of(
// GL_COLOR_MATERIAL enable bit
// GL_COLOR_MATERIAL_FACE value
// Color material parameters that are tracking the current color
// Ambient scene color
// GL_LIGHT_MODEL_LOCAL_VIEWER value
// GL_LIGHT_MODEL_TWO_SIDE setting
// GL_LIGHTING enable bit
// Enable bit for each light
// Ambient, diffuse, and specular intensity for each light
// Direction, position, exponent, and cutoff angle for each light
// Constant, linear, and quadratic attenuation factors for each light
// Ambient, diffuse, specular, and emissive color for each material
// Ambient, diffuse, and specular color indices for each material
// Specular exponent for each material
// GL_SHADE_MODEL setting
));
attribToFeatures.put(GL11.GL_LINE_BIT, ImmutableSet.of(
// GL_LINE_SMOOTH flag
// GL_LINE_STIPPLE enable bit
// Line stipple pattern and repeat counter
// Line width
));
attribToFeatures.put(GL11.GL_LIST_BIT, ImmutableSet.of(
// GL_LIST_BASE setting
));
attribToFeatures.put(GL13.GL_MULTISAMPLE_BIT, ImmutableSet.of(
// GL_MULTISAMPLE enable bit
// GL_SAMPLE_ALPHA_TO_COVERAGE flag
// GL_SAMPLE_ALPHA_TO_ONE flag
// GL_SAMPLE_COVERAGE flag
// GL_SAMPLE_COVERAGE_VALUE value
// GL_SAMPLE_COVERAGE_INVERT value
));
attribToFeatures.put(GL11.GL_PIXEL_MODE_BIT, ImmutableSet.of(
// GL_RED_BIAS and GL_RED_SCALE settings
// GL_GREEN_BIAS and GL_GREEN_SCALE values
// GL_BLUE_BIAS and GL_BLUE_SCALE
// GL_ALPHA_BIAS and GL_ALPHA_SCALE
// GL_DEPTH_BIAS and GL_DEPTH_SCALE
// GL_INDEX_OFFSET and GL_INDEX_SHIFT values
// GL_MAP_COLOR and GL_MAP_STENCIL flags
// GL_ZOOM_X and GL_ZOOM_Y factors
// GL_READ_BUFFER setting
));
attribToFeatures.put(GL11.GL_POINT_BIT, ImmutableSet.of(
// GL_POINT_SMOOTH flag
// Point size
));
attribToFeatures.put(GL11.GL_POLYGON_BIT, ImmutableSet.of(
GLStateManager.cullState // GL_CULL_FACE enable bit
// GL_CULL_FACE_MODE value
// GL_FRONT_FACE indicator
// GL_POLYGON_MODE setting
// GL_POLYGON_SMOOTH flag
// GL_POLYGON_STIPPLE enable bit
// GL_POLYGON_OFFSET_FILL flag
// GL_POLYGON_OFFSET_LINE flag
// GL_POLYGON_OFFSET_POINT flag
// GL_POLYGON_OFFSET_FACTOR
// GL_POLYGON_OFFSET_UNITS
));
attribToFeatures.put(GL11.GL_POLYGON_STIPPLE_BIT, ImmutableSet.of(
// Polygon stipple pattern
));
attribToFeatures.put(GL11.GL_SCISSOR_BIT, ImmutableSet.of(
// GL_SCISSOR_TEST enable bit
// Scissor box
));
attribToFeatures.put(GL11.GL_STENCIL_BUFFER_BIT, ImmutableSet.of(
// GL_STENCIL_TEST enable bit
// Stencil function and reference value
// Stencil value mask
// Stencil fail, pass, and depth buffer pass actions
// Stencil buffer clear value
// Stencil buffer writemask
));
final Set<IStateStack<?>> textureAttribs = new HashSet<>(ImmutableSet.of(
// Enable bits for the four texture coordinates
// Border color for each texture image
// Minification function for each texture image
// Magnification function for each texture image
// Texture coordinates and wrap mode for each texture image
// Color and mode for each texture environment
// Enable bits GL_TEXTURE_GEN_x, x is S, T, R, and Q
// GL_TEXTURE_GEN_MODE setting for S, T, R, and Q
// glTexGen plane equations for S, T, R, and Q
// Current texture bindings (for example, GL_TEXTURE_BINDING_2D) - Below
));
// Current Texture Bindings - GL_TEXTURE_BINDING_2D
for(int i = 0 ; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
textureAttribs.add(GLStateManager.textures.getTextureUnitBindings(i));
}
attribToFeatures.put(GL11.GL_TEXTURE_BIT, textureAttribs);
attribToFeatures.put(GL11.GL_TRANSFORM_BIT, ImmutableSet.of(
// Coefficients of the six clipping planes
// Enable bits for the user-definable clipping planes
GLStateManager.matrixMode
// GL_NORMALIZE flag
// GL_RESCALE_NORMAL flag
));
attribToFeatures.put(GL11.GL_VIEWPORT_BIT, ImmutableSet.of(
// Depth range (near and far)
GLStateManager.viewportState
));
}
public static Set<IStateStack<?>> getFeatures(int attrib) {
return attribToFeatures.getOrDefault(attrib, Collections.emptySet());
}
}
@@ -1,22 +1,30 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.glsm.states.AlphaState;
import com.gtnewhorizons.angelica.glsm.states.BlendState;
import com.gtnewhorizons.angelica.glsm.states.BooleanState;
import com.gtnewhorizons.angelica.glsm.stacks.AlphaStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.BlendStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.Color4Stack;
import com.gtnewhorizons.angelica.glsm.stacks.ColorMaskStack;
import com.gtnewhorizons.angelica.glsm.stacks.DepthStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.FogStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
import com.gtnewhorizons.angelica.glsm.stacks.ViewPortStateStack;
import com.gtnewhorizons.angelica.glsm.states.Color4;
import com.gtnewhorizons.angelica.glsm.states.DepthState;
import com.gtnewhorizons.angelica.glsm.states.FogState;
import com.gtnewhorizons.angelica.glsm.states.GLColorMask;
import com.gtnewhorizons.angelica.glsm.states.TextureState;
import com.gtnewhorizons.angelica.glsm.states.TextureBinding;
import com.gtnewhorizons.angelica.glsm.states.TextureUnitArray;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntStack;
import lombok.Getter;
import net.coderbot.iris.Iris;
import net.coderbot.iris.gbuffer_overrides.state.StateTracker;
import net.coderbot.iris.gl.blending.AlphaTestStorage;
import net.coderbot.iris.gl.blending.BlendModeStorage;
import net.coderbot.iris.gl.blending.DepthColorStorage;
import net.coderbot.iris.gl.sampler.SamplerLimits;
import net.coderbot.iris.gl.state.StateUpdateNotifiers;
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
import net.coderbot.iris.samplers.IrisSamplers;
@@ -24,45 +32,69 @@ import net.coderbot.iris.texture.TextureInfoCache;
import net.coderbot.iris.texture.TextureTracker;
import net.coderbot.iris.texture.pbr.PBRTextureManager;
import net.minecraft.client.renderer.OpenGlHelper;
import org.joml.Matrix4d;
import org.joml.Matrix4f;
import org.joml.Matrix4fStack;
import org.joml.Vector3d;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.ARBMultitexture;
import org.lwjgl.opengl.Drawable;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import org.lwjgl.opengl.GL13;
import org.lwjgl.opengl.GL20;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.stream.IntStream;
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
@SuppressWarnings("unused") // Used in ASM
public class GLStateManager {
public static final boolean BYPASS_CACHE = Boolean.parseBoolean(System.getProperty("angelica.disableGlCache", "false"));
public static final int MAX_ATTRIB_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_ATTRIB_STACK_DEPTH);
public static final int MAX_MODELVIEW_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_MODELVIEW_STACK_DEPTH);
public static final int MAX_PROJECTION_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_PROJECTION_STACK_DEPTH);
public static final int MAX_TEXTURE_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_TEXTURE_STACK_DEPTH);
public static final int MAX_TEXTURE_UNITS = GL11.glGetInteger(GL20.GL_MAX_TEXTURE_IMAGE_UNITS);
// GLStateManager State Trackers
@Getter private static int activeTexture;
@Getter private static final BlendState blendState = new BlendState();
@Getter private static final DepthState depthState = new DepthState();
@Getter private static final FogState fogState = new FogState();
@Getter private static final Color4 Color = new Color4();
@Getter private static final Color4 ClearColor = new Color4();
@Getter private static final GLColorMask ColorMask = new GLColorMask();
@Getter private static final BooleanState cullState = new BooleanState(GL11.GL_CULL_FACE);
@Getter private static final AlphaState alphaState = new AlphaState();
@Getter private static final BooleanState lightingState = new BooleanState(GL11.GL_LIGHTING);
@Getter private static final BooleanState rescaleNormalState = new BooleanState(GL12.GL_RESCALE_NORMAL);
private static final IntStack attribs = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
private static final IntStack activeTextureUnit = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
static {
activeTextureUnit.push(0); // GL_TEXTURE0
}
@Getter protected static final TextureUnitArray textures = new TextureUnitArray();
@Getter protected static final BlendStateStack blendState = new BlendStateStack();
@Getter protected static final BooleanStateStack blendMode = new BooleanStateStack(GL11.GL_BLEND);
@Getter protected static final DepthStateStack depthState = new DepthStateStack();
@Getter protected static final BooleanStateStack depthTest = new BooleanStateStack(GL11.GL_DEPTH_TEST);
private static long dirty = 0;
// @Getter private static final FogState fogState = new FogState();
@Getter protected static final FogStateStack fogState = new FogStateStack();
@Getter protected static final BooleanStateStack fogMode = new BooleanStateStack(GL11.GL_FOG);
@Getter protected static final Color4Stack color = new Color4Stack();
@Getter protected static final Color4Stack clearColor = new Color4Stack();
@Getter protected static final ColorMaskStack colorMask = new ColorMaskStack();
@Getter protected static final BooleanStateStack cullState = new BooleanStateStack(GL11.GL_CULL_FACE);
@Getter protected static final AlphaStateStack alphaState = new AlphaStateStack();
@Getter protected static final BooleanStateStack alphaTest = new BooleanStateStack(GL11.GL_ALPHA_TEST);
@Getter protected static final BooleanStateStack lightingState = new BooleanStateStack(GL11.GL_LIGHTING);
@Getter protected static final BooleanStateStack rescaleNormalState = new BooleanStateStack(GL12.GL_RESCALE_NORMAL);
@Getter protected static final MatrixModeStack matrixMode = new MatrixModeStack();
@Getter protected static final Matrix4fStack modelViewMatrix = new Matrix4fStack(MAX_MODELVIEW_STACK_DEPTH);
@Getter protected static final Matrix4fStack projectionMatrix = new Matrix4fStack(MAX_PROJECTION_STACK_DEPTH);
@Getter protected static final Matrix4fStack textureMatrix = new Matrix4fStack(MAX_TEXTURE_STACK_DEPTH);
@Getter protected static final ViewPortStateStack viewportState = new ViewPortStateStack();
private static int modelShadeMode;
@Getter
private static TextureState[] Textures;
// Iris Listeners
private static Runnable blendFuncListener = null;
private static Runnable fogToggleListener = null;
@@ -77,7 +109,7 @@ public class GLStateManager {
private static Thread CurrentThread = MainThread;
private static boolean runningSplash = false;
private static boolean inGLNewList = false;
private static int glListMode = 0;
private static boolean hudCaching$blendEnabled;
@@ -90,8 +122,6 @@ public class GLStateManager {
StateUpdateNotifiers.fogEndNotifier = listener -> fogEndListener = listener;
StateUpdateNotifiers.fogDensityNotifier = listener -> fogDensityListener = listener;
}
// We want textures regardless of Iris being initialized, and using SamplerLimits is isolated enough
Textures = IntStream.range(0, SamplerLimits.get().getMaxTextureUnits()).mapToObj(i -> new TextureState()).toArray(TextureState[]::new);
}
public static void assertMainThread() {
@@ -129,6 +159,19 @@ public class GLStateManager {
}
}
public static void glGetFloat(int pname, FloatBuffer params) {
switch (pname) {
case GL11.GL_MODELVIEW_MATRIX -> modelViewMatrix.get(params);
case GL11.GL_PROJECTION_MATRIX -> projectionMatrix.get(params);
case GL11.GL_TEXTURE_MATRIX -> textureMatrix.get(params);
default -> GL11.glGetFloat(pname, params);
}
}
public static float glGetFloat(int pname) {
return GL11.glGetFloat(pname);
}
// GLStateManager Functions
public static void enableBlend() {
@@ -139,7 +182,7 @@ public class GLStateManager {
}
}
hudCaching$blendEnabled = true;
blendState.mode.enable();
blendMode.enable();
}
public static void disableBlend() {
@@ -150,7 +193,7 @@ public class GLStateManager {
}
}
hudCaching$blendEnabled = false;
blendState.mode.disable();
blendMode.disable();
}
public static void glBlendFunc(int srcFactor, int dstFactor) {
@@ -161,17 +204,16 @@ public class GLStateManager {
}
}
if (HUDCaching.renderingCacheOverride) {
blendState.srcRgb = srcFactor;
blendState.dstRgb = dstFactor;
blendState.srcAlpha = GL11.GL_ONE;
blendState.dstAlpha = GL11.GL_ONE_MINUS_SRC_ALPHA;
blendState.setSrcRgb(srcFactor);
blendState.setDstRgb(dstFactor);
blendState.setSrcAlpha(GL11.GL_ONE);
blendState.setDstAlpha(GL11.GL_ONE_MINUS_SRC_ALPHA);
OpenGlHelper.glBlendFunc(srcFactor, dstFactor, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
clean(Dirty.BLEND_STATE);
return;
}
if (GLStateManager.BYPASS_CACHE || blendState.srcRgb != srcFactor || blendState.dstRgb != dstFactor || checkDirty(Dirty.BLEND_STATE)) {
blendState.srcRgb = srcFactor;
blendState.dstRgb = dstFactor;
if (GLStateManager.BYPASS_CACHE || blendState.getSrcRgb() != srcFactor || blendState.getDstRgb() != dstFactor) {
blendState.setSrcRgb(srcFactor);
blendState.setDstRgb(dstFactor);
GL11.glBlendFunc(srcFactor, dstFactor);
}
@@ -190,11 +232,12 @@ public class GLStateManager {
srcAlpha = GL11.GL_ONE;
dstAlpha = GL11.GL_ONE_MINUS_SRC_ALPHA;
}
if (GLStateManager.BYPASS_CACHE || blendState.srcRgb != srcRgb || blendState.dstRgb != dstRgb || blendState.srcAlpha != srcAlpha || blendState.dstAlpha != dstAlpha || checkDirty(Dirty.BLEND_STATE)) {
blendState.srcRgb = srcRgb;
blendState.dstRgb = dstRgb;
blendState.srcAlpha = srcAlpha;
blendState.dstAlpha = dstAlpha;
if (GLStateManager.BYPASS_CACHE || blendState.getSrcRgb() != srcRgb || blendState.getDstRgb() != dstRgb || blendState.getSrcAlpha()
!= srcAlpha || blendState.getDstAlpha() != dstAlpha) {
blendState.setSrcRgb(srcRgb);
blendState.setDstRgb(dstRgb);
blendState.setSrcAlpha(srcAlpha);
blendState.setDstAlpha(dstAlpha);
OpenGlHelper.glBlendFunc(srcRgb, dstRgb, srcAlpha, dstAlpha);
}
@@ -204,8 +247,8 @@ public class GLStateManager {
public static void glDepthFunc(int func) {
// Hacky workaround for now, need to figure out why this isn't being applied...
if (GLStateManager.BYPASS_CACHE || func != depthState.func || GLStateManager.runningSplash || checkDirty(Dirty.DEPTH_FUNC)) {
depthState.func = func;
if (GLStateManager.BYPASS_CACHE || func != depthState.getFunc() || GLStateManager.runningSplash) {
depthState.setFunc(func);
GL11.glDepthFunc(func);
}
}
@@ -218,8 +261,8 @@ public class GLStateManager {
}
}
if (mask != depthState.mask || checkDirty(Dirty.DEPTH_MASK)) {
depthState.mask = mask;
if (mask != depthState.isMask()) {
depthState.setMask(mask);
GL11.glDepthMask(mask);
}
}
@@ -294,19 +337,20 @@ public class GLStateManager {
private static boolean changeColor(float red, float green, float blue, float alpha) {
// Helper function for glColor*
if (GLStateManager.BYPASS_CACHE || red != Color.red || green != Color.green || blue != Color.blue || alpha != Color.alpha || checkDirty(Dirty.COLOR)) {
Color.red = red;
Color.green = green;
Color.blue = blue;
Color.alpha = alpha;
if (GLStateManager.BYPASS_CACHE || red != color.getRed() || green != color.getGreen() || blue != color.getBlue() || alpha != color.getAlpha()) {
color.setRed(red);
color.setGreen(green);
color.setBlue(blue);
color.setAlpha(alpha);
return true;
}
return false;
}
private static final Color4 DirtyColor = new Color4(-1.0F, -1.0F, -1.0F, -1.0F);
public static void clearCurrentColor() {
// Marks the cache dirty, doesn't actually reset the color
dirty(Dirty.COLOR);
color.set(DirtyColor);
}
public static void glColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
@@ -316,22 +360,22 @@ public class GLStateManager {
return;
}
}
if (GLStateManager.BYPASS_CACHE || red != ColorMask.red || green != ColorMask.green || blue != ColorMask.blue || alpha != ColorMask.alpha || checkDirty(Dirty.COLOR_MASK)) {
ColorMask.red = red;
ColorMask.green = green;
ColorMask.blue = blue;
ColorMask.alpha = alpha;
if (GLStateManager.BYPASS_CACHE || red != colorMask.red || green != colorMask.green || blue != colorMask.blue || alpha != colorMask.alpha) {
colorMask.red = red;
colorMask.green = green;
colorMask.blue = blue;
colorMask.alpha = alpha;
GL11.glColorMask(red, green, blue, alpha);
}
}
// Clear Color
public static void glClearColor(float red, float green, float blue, float alpha) {
if (GLStateManager.BYPASS_CACHE || red != ClearColor.red || green != ClearColor.green || blue != ClearColor.blue || alpha != ClearColor.alpha || checkDirty(Dirty.CLEAR_COLOR)) {
ClearColor.red = red;
ClearColor.green = green;
ClearColor.blue = blue;
ClearColor.alpha = alpha;
if (GLStateManager.BYPASS_CACHE || red != clearColor.getRed() || green != clearColor.getGreen() || blue != clearColor.getBlue() || alpha != clearColor.getAlpha()) {
clearColor.setRed(red);
clearColor.setGreen(green);
clearColor.setBlue(blue);
clearColor.setAlpha(alpha);
GL11.glClearColor(red, green, blue, alpha);
}
}
@@ -344,7 +388,7 @@ public class GLStateManager {
return;
}
}
alphaState.mode.enable();
alphaTest.enable();
}
public static void disableAlphaTest() {
@@ -354,7 +398,7 @@ public class GLStateManager {
return;
}
}
alphaState.mode.disable();
alphaTest.disable();
}
public static void glAlphaFunc(int function, float reference) {
@@ -364,41 +408,55 @@ public class GLStateManager {
return;
}
}
alphaState.function = function;
alphaState.reference = reference;
alphaState.setFunction(function);
alphaState.setReference(reference);
GL11.glAlphaFunc(function, reference);
}
// Textures
public static void glActiveTexture(int texture) {
final int newTexture = texture - GL13.GL_TEXTURE0;
if (GLStateManager.BYPASS_CACHE || activeTexture != newTexture || checkDirty(Dirty.ACTIVE_TEXTURE)) {
activeTexture = newTexture;
if (GLStateManager.BYPASS_CACHE || getActiveTextureUnit() != newTexture) {
activeTextureUnit.popInt();
activeTextureUnit.push(newTexture);
GL13.glActiveTexture(texture);
}
}
public static void glActiveTextureARB(int texture) {
final int newTexture = texture - GL13.GL_TEXTURE0;
if (GLStateManager.BYPASS_CACHE || activeTexture != newTexture || checkDirty(Dirty.ACTIVE_TEXTURE)) {
activeTexture = newTexture;
if (GLStateManager.BYPASS_CACHE || getActiveTextureUnit() != newTexture) {
activeTextureUnit.popInt();
activeTextureUnit.push(newTexture);
ARBMultitexture.glActiveTextureARB(texture);
}
}
public static int getBoundTexture() {
return textures.getTextureUnitBindings(activeTextureUnit.topInt()).getBinding();
}
public static void glBindTexture(int target, int texture) {
if(inGLNewList) {
// Binding a texture, while building a list, is not allowed and is a silent noop
Throwable throwable = new Throwable();
LOGGER.info("Naughty naughty, someone's making a texture binding in a display list!", throwable);
if(target != GL11.GL_TEXTURE_2D) {
// We're only supporting 2D textures for now
GL11.glBindTexture(target, texture);
return;
}
// TODO: Do we need to do the check dirty for each bound texture?
if (GLStateManager.BYPASS_CACHE || Textures[activeTexture].binding != texture || runningSplash || checkDirty(Dirty.BOUND_TEXTURE)) {
GL11.glBindTexture(target, texture);
if(glListMode == GL11.GL_COMPILE ) {
if(AngelicaMod.lwjglDebug) {
// Binding a texture, while building a list, is not allowed and is a silent noop
final Throwable throwable = new Throwable();
LOGGER.info("Naughty naughty, someone's making a texture binding in a display list!", throwable);
}
return;
}
Textures[activeTexture].binding = texture;
final TextureBinding textureUnit = textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt());
if (GLStateManager.BYPASS_CACHE || textureUnit.getBinding() != texture || runningSplash) {
GL11.glBindTexture(target, texture);
textureUnit.setBinding(texture);
if (AngelicaConfig.enableIris) {
TextureTracker.INSTANCE.onBindTexture(texture);
}
@@ -431,7 +489,7 @@ public class GLStateManager {
if (AngelicaConfig.enableIris) {
iris$onDeleteTexture(id);
}
Textures[activeTexture].binding = -1;
textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt()).setBinding(-1);
GL11.glDeleteTextures(id);
}
@@ -441,21 +499,22 @@ public class GLStateManager {
iris$onDeleteTexture(ids.get(i));
}
}
Textures[activeTexture].binding = -1;
textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt()).setBinding(-1);
GL11.glDeleteTextures(ids);
}
public static void enableTexture() {
final int textureUnit = getActiveTextureUnit();
if (AngelicaConfig.enableIris) {
// Iris
boolean updatePipeline = false;
if (activeTexture == IrisSamplers.ALBEDO_TEXTURE_UNIT) {
if (textureUnit == IrisSamplers.ALBEDO_TEXTURE_UNIT) {
StateTracker.INSTANCE.albedoSampler = true;
updatePipeline = true;
} else if (activeTexture == IrisSamplers.LIGHTMAP_TEXTURE_UNIT) {
} else if (textureUnit == IrisSamplers.LIGHTMAP_TEXTURE_UNIT) {
StateTracker.INSTANCE.lightmapSampler = true;
updatePipeline = true;
} else if (activeTexture == IrisSamplers.OVERLAY_TEXTURE_UNIT) {
} else if (textureUnit == IrisSamplers.OVERLAY_TEXTURE_UNIT) {
StateTracker.INSTANCE.overlaySampler = true;
updatePipeline = true;
}
@@ -464,20 +523,21 @@ public class GLStateManager {
Iris.getPipelineManager().getPipeline().ifPresent(p -> p.setInputs(StateTracker.INSTANCE.getInputs()));
}
}
Textures[activeTexture].mode.enable();
textures.getTextureUnitStates(textureUnit).enable();
}
public static void disableTexture() {
final int textureUnit = getActiveTextureUnit();
if (AngelicaConfig.enableIris) {
// Iris
boolean updatePipeline = false;
if (activeTexture == IrisSamplers.ALBEDO_TEXTURE_UNIT) {
if (textureUnit == IrisSamplers.ALBEDO_TEXTURE_UNIT) {
StateTracker.INSTANCE.albedoSampler = false;
updatePipeline = true;
} else if (activeTexture == IrisSamplers.LIGHTMAP_TEXTURE_UNIT) {
} else if (textureUnit == IrisSamplers.LIGHTMAP_TEXTURE_UNIT) {
StateTracker.INSTANCE.lightmapSampler = false;
updatePipeline = true;
} else if (activeTexture == IrisSamplers.OVERLAY_TEXTURE_UNIT) {
} else if (textureUnit == IrisSamplers.OVERLAY_TEXTURE_UNIT) {
StateTracker.INSTANCE.overlaySampler = false;
updatePipeline = true;
}
@@ -486,7 +546,7 @@ public class GLStateManager {
Iris.getPipelineManager().getPipeline().ifPresent(p -> p.setInputs(StateTracker.INSTANCE.getInputs()));
}
}
Textures[activeTexture].mode.disable();
textures.getTextureUnitStates(textureUnit).disable();
}
public static void setFilter(boolean bilinear, boolean mipmap) {
@@ -521,11 +581,11 @@ public class GLStateManager {
}
public static void enableDepthTest() {
depthState.mode.enable();
depthTest.enable();
}
public static void disableDepthTest() {
depthState.mode.disable();
depthTest.disable();
}
public static void enableLighting() {
@@ -545,14 +605,14 @@ public class GLStateManager {
}
public static void enableFog() {
fogState.mode.enable();
fogMode.enable();
if (fogToggleListener != null) {
fogToggleListener.run();
}
}
public static void disableFog() {
fogState.mode.disable();
fogMode.disable();
if (fogToggleListener != null) {
fogToggleListener.run();
}
@@ -566,44 +626,45 @@ public class GLStateManager {
final float green = param.get(1);
final float blue = param.get(2);
fogState.fogColor.set(red, green, blue);
fogState.fogAlpha = param.get(3);
fogState.fogColorBuffer.clear();
fogState.fogColorBuffer.put((FloatBuffer) param.position(0)).flip();
fogState.getFogColor().set(red, green, blue);
fogState.setFogAlpha(param.get(3));
fogState.getFogColorBuffer().clear();
fogState.getFogColorBuffer().put((FloatBuffer) param.position(0)).flip();
}
}
public static Vector3d getFogColor() {
return fogState.fogColor;
return fogState.getFogColor();
}
public static void fogColor(float red, float green, float blue, float alpha) {
if (GLStateManager.BYPASS_CACHE || red != fogState.fogColor.x || green != fogState.fogColor.y || blue != fogState.fogColor.z || alpha != fogState.fogAlpha) {
fogState.fogColor.set(red, green, blue);
fogState.fogAlpha = alpha;
fogState.fogColorBuffer.clear();
fogState.fogColorBuffer.put(red).put(green).put(blue).put(alpha).flip();
GL11.glFog(GL11.GL_FOG_COLOR, fogState.fogColorBuffer);
if (GLStateManager.BYPASS_CACHE || red != fogState.getFogColor().x || green != fogState.getFogColor().y || blue != fogState.getFogColor().z || alpha != fogState.getFogAlpha()) {
fogState.getFogColor().set(red, green, blue);
fogState.setFogAlpha(alpha);
fogState.getFogColorBuffer().clear();
fogState.getFogColorBuffer().put(red).put(green).put(blue).put(alpha).flip();
GL11.glFog(GL11.GL_FOG_COLOR, fogState.getFogColorBuffer());
}
}
public static void glFogf(int pname, float param) {
GL11.glFogf(pname, param);
// Note: Does not handle GL_FOG_INDEX
switch (pname) {
case GL11.GL_FOG_DENSITY -> {
fogState.density = param;
fogState.setDensity(param);
if (fogDensityListener != null) {
fogDensityListener.run();
}
}
case GL11.GL_FOG_START -> {
fogState.start = param;
fogState.setStart(param);
if (fogStartListener != null) {
fogStartListener.run();
}
}
case GL11.GL_FOG_END -> {
fogState.end = param;
fogState.setEnd(param);
if (fogEndListener != null) {
fogEndListener.run();
}
@@ -614,7 +675,7 @@ public class GLStateManager {
public static void glFogi(int pname, int param) {
GL11.glFogi(pname, param);
if (pname == GL11.GL_FOG_MODE) {
fogState.fogMode = param;
fogState.setFogMode(param);
if (fogModeListener != null) {
fogModeListener.run();
}
@@ -626,7 +687,7 @@ public class GLStateManager {
}
public static void glShadeModel(int mode) {
if (GLStateManager.BYPASS_CACHE || modelShadeMode != mode || checkDirty(Dirty.SHADE_MODEL)) {
if (GLStateManager.BYPASS_CACHE || modelShadeMode != mode) {
modelShadeMode = mode;
GL11.glShadeModel(mode);
}
@@ -654,44 +715,158 @@ public class GLStateManager {
}
public static void glNewList(int list, int mode) {
if(inGLNewList) {
if(glListMode > 0) {
throw new RuntimeException("glNewList called inside of a display list!");
}
inGLNewList = true;
glListMode = mode;
GL11.glNewList(list, mode);
}
public static void glEndList() {
if(!inGLNewList) {
if(glListMode == 0) {
throw new RuntimeException("glEndList called outside of a display list!");
}
inGLNewList = false;
glListMode = 0;
GL11.glEndList();
}
public static void glPushAttrib(int mask) {
// TODO: Proper state tracking; but at least for now the current cases of this didn't do anything related to textures and
// just overly broadly set ALL_BITS :facepalm:
GL11.glPushAttrib(mask & ~(GL11.GL_TEXTURE_BIT));
attribs.push(mask);
for(IStateStack<?> stack : Feature.maskToFeatures(mask)) {
stack.push();
}
GL11.glPushAttrib(mask);
}
public static void glPopAttrib() {
dirty = Dirty.ALL;
final int mask = attribs.pop();
for(IStateStack<?> stack : Feature.maskToFeatures(mask)) {
stack.pop();
}
GL11.glPopAttrib();
}
public static boolean checkDirty(long flag) {
if((dirty & flag ) == flag) {
dirty &= ~flag;
return true;
}
return false;
}
public static void clean(long dirtyFlag) {
dirty &= ~dirtyFlag;
// Matrix Operations
public static void glMatrixMode(int mode) {
matrixMode.setMode(mode);
}
public static void dirty(long dirtyFlag) {
dirty |= dirtyFlag;
public static Matrix4fStack getMatrixStack() {
switch (matrixMode.getMode()) {
case GL11.GL_MODELVIEW -> {
return modelViewMatrix;
}
case GL11.GL_PROJECTION -> {
return projectionMatrix;
}
case GL11.GL_TEXTURE -> {
return textureMatrix;
}
default -> throw new IllegalStateException("Unknown matrix mode: " + matrixMode.getMode());
}
}
public static void glLoadIdentity() {
GL11.glLoadIdentity();
getMatrixStack().identity();
}
public static void glTranslatef(float x, float y, float z) {
GL11.glTranslatef(x, y, z);
getMatrixStack().translate(x, y, z);
}
public static void glTranslated(double x, double y, double z) {
GL11.glTranslated(x, y, z);
getMatrixStack().translate((float) x, (float) y, (float) z);
}
public static void glScalef(float x, float y, float z) {
GL11.glScalef(x, y, z);
getMatrixStack().scale(x, y, z);
}
public static void glScaled(double x, double y, double z) {
GL11.glScaled(x, y, z);
getMatrixStack().scale((float) x, (float) y, (float) z);
}
private static final Matrix4f tempMatrix4f = new Matrix4f();
public static void glMultMatrix(FloatBuffer floatBuffer) {
GL11.glMultMatrix(floatBuffer);
tempMatrix4f.set(floatBuffer);
getMatrixStack().mul(conersionMatrix4f);
}
public static final Matrix4d conersionMatrix4d = new Matrix4d();
public static final Matrix4f conersionMatrix4f = new Matrix4f();
public static void glMultMatrix(DoubleBuffer matrix) {
GL11.glMultMatrix(matrix);
conersionMatrix4d.set(matrix);
conersionMatrix4f.set(conersionMatrix4d);
getMatrixStack().mul(conersionMatrix4f);
}
public static void glRotatef(float angle, float x, float y, float z) {
GL11.glRotatef(angle, x, y, z);
getMatrixStack().rotate((float)Math.toRadians(angle), x, y, z);
}
public static void glRotated(double angle, double x, double y, double z) {
GL11.glRotated(angle, x, y, z);
getMatrixStack().rotate((float)Math.toRadians(angle), (float) x, (float) y, (float) z);
}
public static void glOrtho(double left, double right, double bottom, double top, double zNear, double zFar) {
GL11.glOrtho(left, right, bottom, top, zNear, zFar);
getMatrixStack().ortho((float)left, (float)right, (float)bottom, (float)top, (float)zNear, (float)zFar);
}
public static void glFrustum(double left, double right, double bottom, double top, double zNear, double zFar) {
GL11.glFrustum(left, right, bottom, top, zNear, zFar);
getMatrixStack().frustum((float)left, (float)right, (float)bottom, (float)top, (float)zNear, (float)zFar);
}
public static void glPushMatrix() {
GL11.glPushMatrix();
try {
getMatrixStack().pushMatrix();
} catch(IllegalStateException ignored) {
// Ignore
if(AngelicaMod.lwjglDebug)
AngelicaTweaker.LOGGER.warn("Matrix stack overflow ", new Throwable());
}
}
public static void glPopMatrix() {
GL11.glPopMatrix();
try {
getMatrixStack().popMatrix();
} catch(IllegalStateException ignored) {
// Ignore
if(AngelicaMod.lwjglDebug)
AngelicaTweaker.LOGGER.warn("Matrix stack underflow ", new Throwable());
}
}
private static final Matrix4f perspectiveMatrix = new Matrix4f();
private static final FloatBuffer perspectiveBuffer = BufferUtils.createFloatBuffer(16);
public static void gluPerspective(float fovy, float aspect, float zNear, float zFar) {
perspectiveMatrix.identity().perspective((float)Math.toRadians(fovy), aspect, zNear, zFar);
perspectiveMatrix.get(0, perspectiveBuffer);
GL11.glMultMatrix(perspectiveBuffer);
getMatrixStack().mul(perspectiveMatrix);
}
public static void glViewport(int x, int y, int width, int height) {
GL11.glViewport(x, y, width, height);
viewportState.setViewPort(x, y, width, height);
}
public static int getActiveTextureUnit() {
return activeTextureUnit.topInt();
}
}
@@ -17,7 +17,7 @@ public class TessellatorManager {
}
public static boolean isMainInstance(Object instance) {
return instance == Tessellator.instance;
return instance == Tessellator.instance || isOnMainThread();
}
static {
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.AlphaState;
public class AlphaStateStack extends AlphaState implements IStateStack<AlphaState> {
protected final AlphaState[] stack;
protected int pointer;
public AlphaStateStack() {
stack = new AlphaState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new AlphaState();
}
}
public AlphaStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public AlphaStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.BlendState;
public class BlendStateStack extends BlendState implements IStateStack<BlendStateStack> {
protected final BlendState[] stack;
protected int pointer;
public BlendStateStack() {
stack = new BlendState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new BlendState();
}
}
public BlendStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public BlendStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,38 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.BooleanState;
public class BooleanStateStack extends BooleanState implements IStateStack<BooleanStateStack> {
protected final BooleanState[] stack;
protected int pointer;
public BooleanStateStack(int glCap) {
super(glCap);
stack = new BooleanState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new BooleanState(glCap);
}
}
public BooleanStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public BooleanStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.Color4;
public class Color4Stack extends Color4 implements IStateStack<Color4Stack> {
protected final Color4[] stack;
protected int pointer;
public Color4Stack() {
stack = new Color4[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new Color4();
}
}
public Color4Stack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public Color4Stack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.ColorMask;
public class ColorMaskStack extends ColorMask implements IStateStack<ColorMaskStack> {
protected final ColorMask[] stack;
protected int pointer;
public ColorMaskStack() {
stack = new ColorMask[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new ColorMask();
}
}
public ColorMaskStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public ColorMaskStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.DepthState;
public class DepthStateStack extends DepthState implements IStateStack<DepthStateStack> {
protected final DepthState[] stack;
protected int pointer;
public DepthStateStack() {
stack = new DepthState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new DepthState();
}
}
public DepthStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public DepthStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.FogState;
public class FogStateStack extends FogState implements IStateStack<FogStateStack> {
protected final FogState[] stack;
protected int pointer;
public FogStateStack() {
stack = new FogState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new FogState();
}
}
public FogStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public FogStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,9 @@
package com.gtnewhorizons.angelica.glsm.stacks;
public interface IStateStack<T>{
T push();
T pop();
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.MatrixMode;
public class MatrixModeStack extends MatrixMode implements IStateStack<MatrixModeStack> {
protected final MatrixMode[] stack;
protected int pointer;
public MatrixModeStack() {
stack = new MatrixMode[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new MatrixMode();
}
}
public MatrixModeStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public MatrixModeStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -0,0 +1,40 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.TextureBinding;
public class TextureBindingStack extends TextureBinding implements IStateStack<TextureBindingStack> {
protected final TextureBinding[] stack;
protected int pointer;
public TextureBindingStack() {
stack = new TextureBinding[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new TextureBinding();
}
}
public TextureBindingStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public TextureBindingStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
public TextureBinding peek() {
return stack[pointer];
}
}
@@ -0,0 +1,37 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.ViewportState;
public class ViewPortStateStack extends ViewportState implements IStateStack<ViewPortStateStack> {
protected final ViewportState[] stack;
protected int pointer;
public ViewPortStateStack() {
stack = new ViewportState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new ViewportState();
}
}
public ViewPortStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public ViewPortStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -1,9 +1,19 @@
package com.gtnewhorizons.angelica.glsm.states;
import lombok.Getter;
import lombok.Setter;
import org.lwjgl.opengl.GL11;
public class AlphaState {
public final BooleanState mode = new BooleanState(GL11.GL_ALPHA_TEST);
public int function = GL11.GL_ALWAYS;
public float reference = -1.0F;
@Getter
public class AlphaState implements ISettableState<AlphaState> {
@Setter protected int function = GL11.GL_ALWAYS;
@Setter protected float reference = -1.0F;
@Override
public AlphaState set(AlphaState state) {
this.function = state.function;
this.reference = state.reference;
return this;
}
}
@@ -1,13 +1,24 @@
package com.gtnewhorizons.angelica.glsm.states;
import lombok.Getter;
import lombok.Setter;
import org.lwjgl.opengl.GL11;
public class BlendState {
public final BooleanState mode = new BooleanState(GL11.GL_BLEND);
public int srcRgb = GL11.GL_ONE;
public int dstRgb = GL11.GL_ZERO;
public int srcAlpha = GL11.GL_ONE;
public int dstAlpha = GL11.GL_ZERO;
@Getter @Setter
public class BlendState implements ISettableState<BlendState> {
protected int srcRgb = GL11.GL_ONE;
protected int dstRgb = GL11.GL_ZERO;
protected int srcAlpha = GL11.GL_ONE;
protected int dstAlpha = GL11.GL_ZERO;
@Override
public BlendState set(BlendState state) {
this.srcRgb = state.srcRgb;
this.dstRgb = state.dstRgb;
this.srcAlpha = state.srcAlpha;
this.dstAlpha = state.dstAlpha;
return this;
}
}
@@ -5,17 +5,17 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
import lombok.Getter;
import org.lwjgl.opengl.GL11;
public class BooleanState {
private final int cap;
public class BooleanState implements ISettableState<BooleanState> {
private final int glCap;
private final long dirtyFlag;
@Getter
private boolean enabled;
public BooleanState(int cap) {
this.cap = cap;
this.dirtyFlag = Dirty.getFlagFromCap(this.cap);
public BooleanState(int glCap) {
this.glCap = glCap;
this.dirtyFlag = Dirty.getFlagFromCap(this.glCap);
}
public void disable() {
@@ -27,13 +27,19 @@ public class BooleanState {
}
public void setEnabled(boolean enabled) {
if (GLStateManager.BYPASS_CACHE || enabled != this.enabled || GLStateManager.checkDirty(this.dirtyFlag)) {
if (GLStateManager.BYPASS_CACHE || enabled != this.enabled) {
this.enabled = enabled;
if (enabled) {
GL11.glEnable(this.cap);
GL11.glEnable(this.glCap);
} else {
GL11.glDisable(this.cap);
GL11.glDisable(this.glCap);
}
}
}
@Override
public BooleanState set(BooleanState state) {
this.enabled = state.enabled;
return this;
}
}
@@ -1,9 +1,32 @@
package com.gtnewhorizons.angelica.glsm.states;
public class Color4 {
public float red = 1.0F;
public float green = 1.0F;
public float blue = 1.0F;
public float alpha = 1.0F;
import lombok.Getter;
import lombok.Setter;
@Getter @Setter
public class Color4 implements ISettableState<Color4> {
protected float red = 1.0F;
protected float green = 1.0F;
protected float blue = 1.0F;
protected float alpha = 1.0F;
public Color4() {
}
public Color4(float red, float green, float blue, float alpha) {
this.red = red;
this.green = green;
this.blue = blue;
this.alpha = alpha;
}
@Override
public Color4 set(Color4 state) {
this.red = state.red;
this.green = state.green;
this.blue = state.blue;
this.alpha = state.alpha;
return this;
}
}
@@ -0,0 +1,18 @@
package com.gtnewhorizons.angelica.glsm.states;
public class ColorMask implements ISettableState<ColorMask> {
public boolean red = true;
public boolean green = true;
public boolean blue = true;
public boolean alpha = true;
@Override
public ColorMask set(ColorMask state) {
this.red = state.red;
this.green = state.green;
this.blue = state.blue;
this.alpha = state.alpha;
return this;
}
}
@@ -1,10 +1,18 @@
package com.gtnewhorizons.angelica.glsm.states;
import lombok.Getter;
import lombok.Setter;
import org.lwjgl.opengl.GL11;
public class DepthState {
public final BooleanState mode = new BooleanState(GL11.GL_DEPTH_TEST);
public boolean mask = true;
public int func = GL11.GL_LESS;
@Getter @Setter
public class DepthState implements ISettableState<DepthState> {
protected boolean mask = true;
protected int func = GL11.GL_LESS;
@Override
public DepthState set(DepthState state) {
this.mask = state.mask;
this.func = state.func;
return this;
}
}
@@ -1,17 +1,32 @@
package com.gtnewhorizons.angelica.glsm.states;
import lombok.Getter;
import lombok.Setter;
import org.joml.Vector3d;
import org.lwjgl.opengl.GL11;
import java.nio.FloatBuffer;
public class FogState {
public BooleanState mode = new BooleanState(GL11.GL_FOG);
public int fogMode = GL11.GL_EXP;
public final Vector3d fogColor = new Vector3d(0.0F, 0.0F, 0.0F);
public float fogAlpha = 1.0F;
public final FloatBuffer fogColorBuffer = FloatBuffer.allocate(4);
public float density = 1.0F;
public float start;
public float end = 1.0F;
@Getter @Setter
public class FogState implements ISettableState<FogState> {
protected int fogMode = GL11.GL_EXP;
protected final Vector3d fogColor = new Vector3d(0.0F, 0.0F, 0.0F);
protected float fogAlpha = 1.0F;
protected final FloatBuffer fogColorBuffer = FloatBuffer.allocate(4);
protected float density = 1.0F;
protected float start;
protected float end = 1.0F;
@Override
public FogState set(FogState state) {
this.fogMode = state.fogMode;
this.fogColor.set(state.fogColor);
this.fogAlpha = state.fogAlpha;
this.fogColorBuffer.put(0, state.fogColorBuffer.get(0));
this.density = state.density;
this.start = state.start;
this.end = state.end;
return this;
}
}
@@ -1,9 +0,0 @@
package com.gtnewhorizons.angelica.glsm.states;
public class GLColorMask {
public boolean red = true;
public boolean green = true;
public boolean blue = true;
public boolean alpha = true;
}
@@ -0,0 +1,6 @@
package com.gtnewhorizons.angelica.glsm.states;
public interface ISettableState<T> {
T set(T state);
}
@@ -0,0 +1,29 @@
package com.gtnewhorizons.angelica.glsm.states;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import lombok.Getter;
import org.lwjgl.opengl.GL11;
@Getter
public class MatrixMode implements ISettableState<MatrixMode> {
protected int mode = GL11.GL_MODELVIEW;
public void setMode(int mode) {
if(mode != GL11.GL_MODELVIEW && mode != GL11.GL_PROJECTION && mode != GL11.GL_TEXTURE && mode != GL11.GL_COLOR) {
// Invalid mode, do nothing on the cache, but pass it along to OGL
GL11.glMatrixMode(mode);
return;
}
if(this.mode != mode || GLStateManager.BYPASS_CACHE) {
this.mode = mode;
GL11.glMatrixMode(mode);
}
}
@Override
public MatrixMode set(MatrixMode state) {
this.mode = state.mode;
return this;
}
}
@@ -0,0 +1,136 @@
package com.gtnewhorizons.angelica.glsm.states;
import org.joml.Matrix4f;
import org.joml.Matrix4fStack;
import org.lwjgl.opengl.GL11;
import java.nio.FloatBuffer;
public class MatrixState {
public MatrixMode mode = MatrixMode.NONE;
public final Matrix4fStack projectionMatrix;
public final Matrix4fStack modelViewMatrix;
public MatrixState() {
projectionMatrix = new Matrix4fStack(GL11.glGetInteger(GL11.GL_MAX_PROJECTION_STACK_DEPTH));
modelViewMatrix = new Matrix4fStack(GL11.glGetInteger(GL11.GL_MAX_MODELVIEW_STACK_DEPTH));
}
public void identity() {
switch (mode) {
case MODELVIEW -> modelViewMatrix.identity();
case PROJECTION -> projectionMatrix.identity();
default -> {
}
}
}
public void setMode(int mode) {
switch (mode) {
case GL11.GL_MODELVIEW -> this.mode = MatrixMode.MODELVIEW;
case GL11.GL_PROJECTION -> this.mode = MatrixMode.PROJECTION;
case GL11.GL_TEXTURE -> this.mode = MatrixMode.TEXTURE;
default -> throw new RuntimeException("Unsupported matrix mode: " + mode);
}
}
public void translate(float x, float y, float z) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.translate(x, y, z);
case PROJECTION -> projectionMatrix.translate(x, y, z);
default -> {
}
}
}
public void scale(float x, float y, float z) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.scale(x, y, z);
case PROJECTION -> projectionMatrix.scale(x, y, z);
default -> {
}
}
}
private final Matrix4f tempMatrix = new Matrix4f();
public void multiply(FloatBuffer matrix) {
tempMatrix.set(matrix);
switch (mode) {
case MODELVIEW -> modelViewMatrix.mul(tempMatrix);
case PROJECTION -> projectionMatrix.mul(tempMatrix);
default -> {
}
}
}
public void multiply(Matrix4f matrix) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.mul(matrix);
case PROJECTION -> projectionMatrix.mul(matrix);
default -> {
}
}
}
public void rotate(float angle, float x, float y, float z) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.rotate(angle, x, y, z);
case PROJECTION -> projectionMatrix.rotate(angle, x, y, z);
default -> {
}
}
}
public void ortho(double left, double right, double bottom, double top, double zNear, double zFar) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.ortho((float) left, (float) right, (float) bottom, (float) top, (float) zNear, (float) zFar);
case PROJECTION -> projectionMatrix.ortho((float) left, (float) right, (float) bottom, (float) top, (float) zNear, (float) zFar);
default -> {
}
}
}
public void frustum(double left, double right, double bottom, double top, double zNear, double zFar) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.frustum((float) left, (float) right, (float) bottom, (float) top, (float) zNear, (float) zFar);
case PROJECTION -> projectionMatrix.frustum((float) left, (float) right, (float) bottom, (float) top, (float) zNear, (float) zFar);
default -> {
}
}
}
public void push() {
switch (mode) {
case MODELVIEW -> modelViewMatrix.pushMatrix();
case PROJECTION -> projectionMatrix.pushMatrix();
default -> {
}
}
}
public void pop() {
switch (mode) {
case MODELVIEW -> modelViewMatrix.popMatrix();
case PROJECTION -> projectionMatrix.popMatrix();
default -> {
}
}
}
public void perspective(float fovy, float aspect, float zNear, float zFar) {
switch (mode) {
case MODELVIEW -> modelViewMatrix.perspective(fovy, aspect, zNear, zFar);
case PROJECTION -> projectionMatrix.perspective(fovy, aspect, zNear, zFar);
default -> {
}
}
}
enum MatrixMode {
NONE,
MODELVIEW,
PROJECTION,
TEXTURE
}
}
@@ -0,0 +1,15 @@
package com.gtnewhorizons.angelica.glsm.states;
import lombok.Getter;
import lombok.Setter;
@Getter
public class TextureBinding implements ISettableState<TextureBinding> {
@Setter protected int binding;
@Override
public TextureBinding set(TextureBinding state) {
this.binding = state.binding;
return this;
}
}
@@ -1,8 +0,0 @@
package com.gtnewhorizons.angelica.glsm.states;
import org.lwjgl.opengl.GL11;
public class TextureState {
public final BooleanState mode = new BooleanState(GL11.GL_TEXTURE_2D);
public int binding;
}
@@ -0,0 +1,28 @@
package com.gtnewhorizons.angelica.glsm.states;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.TextureBindingStack;
import org.lwjgl.opengl.GL11;
public class TextureUnitArray {
private TextureBindingStack[] bindings;
private BooleanStateStack[] states;
public TextureUnitArray() {
bindings = new TextureBindingStack[GLStateManager.MAX_TEXTURE_UNITS];
states = new BooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
for (int i = 0; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
bindings[i] = new TextureBindingStack();
states[i] = new BooleanStateStack(GL11.GL_TEXTURE_2D);
}
}
public TextureBindingStack getTextureUnitBindings(int index) {
return bindings[index];
}
public BooleanStateStack getTextureUnitStates(int index) {
return states[index];
}
}
@@ -0,0 +1,34 @@
package com.gtnewhorizons.angelica.glsm.states;
import java.nio.IntBuffer;
public class ViewportState implements ISettableState<ViewportState> {
public int x;
public int y;
public int width;
public int height;
public void setViewPort(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
public void get(IntBuffer params) {
params.put(0, x);
params.put(1, y);
params.put(2, width);
params.put(3, height);
}
@Override
public ViewportState set(ViewportState state) {
this.x = state.x;
this.y = state.y;
this.width = state.width;
this.height = state.height;
return this;
}
}
@@ -43,7 +43,9 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader {
LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
LoggerConfig loggerConfig = config.getLoggerConfig(LogManager.ROOT_LOGGER_NAME);
loggerConfig.setLevel(Level.DEBUG);
if (AngelicaConfig.enableDebugLogging) {
loggerConfig.setLevel(Level.DEBUG);
}
ctx.updateLoggers();
} catch (ConfigException e) {
throw new RuntimeException(e);
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.loading;
import com.gtnewhorizons.angelica.transform.BlockTransformer;
import com.gtnewhorizons.angelica.transform.RedirectorTransformer;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.relauncher.FMLLaunchHandler;
@@ -74,6 +75,7 @@ public class MixinCompatHackTweaker implements ITweaker {
if (FMLLaunchHandler.side().isClient()) {
// Run after Mixins, but before LWJGl3ify
Launch.classLoader.registerTransformer(RedirectorTransformer.class.getName());
Launch.classLoader.registerTransformer(BlockTransformer.class.getName());
}
return new String[0];
@@ -25,8 +25,8 @@ public enum Mixins {
ANGELICA(new Builder("Angelica").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
.setPhase(Phase.EARLY).addMixinClasses(
"angelica.MixinEntityRenderer"
"angelica.MixinActiveRenderInfo"
,"angelica.MixinEntityRenderer"
)
),
@@ -135,6 +135,11 @@ public enum Mixins {
)
),
OPTIMIZE_JABBA_GET_INTEGER(new Builder("Optimize Jabba getInteger").setPhase(Phase.LATE)
.addTargetedMod(TargetedMod.JABBA).setSide(Side.CLIENT)
.setApplyIf(() -> AngelicaConfig.optimizeJabbaGetInteger)
.addMixinClasses("client.jabba.MixinTileEntityBaseRenderer")),
ANGELICA_TEXTURE(new Builder("Textures").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.enableIris || AngelicaConfig.enableSodium).addMixinClasses(
@@ -172,6 +177,10 @@ public enum Mixins {
"angelica.animation.MixinWorldRenderer",
"angelica.animation.MixinRenderItem")),
IC2_FLUID_RENDER_FIX(new Builder("IC2 Fluid Render Fix").setPhase(Phase.EARLY).setSide(Side.CLIENT)
.addTargetedMod(TargetedMod.IC2).setApplyIf(() -> AngelicaConfig.speedupAnimations)
.addMixinClasses("angelica.textures.ic2.MixinRenderLiquidCell")),
OPTIMIZE_TEXTURE_LOADING(new Builder("Optimize Texture Loading").setPhase(Phase.EARLY)
.addMixinClasses("angelica.textures.MixinTextureUtil_OptimizeMipmap").addTargetedMod(TargetedMod.VANILLA)
.setApplyIf(() -> AngelicaConfig.optimizeTextureLoading).setSide(Side.CLIENT)),
@@ -12,6 +12,7 @@ public enum TargetedMod {
, COFHCORE("CoFHCore", "cofh.asm.LoadingPlugin", "CoFHCore")
, EXTRAUTILS("ExtraUtilities", null, "ExtraUtilities")
, GTNHLIB("GTNHLib", "com.gtnewhorizon.gtnhlib.core.GTNHLibCore", "gtnhlib")
, IC2("IC2", "ic2.core.coremod.IC2core", "IC2")
, JABBA("JABBA", null, "JABBA")
, JOURNEYMAP("JourneyMap", null, "journeymap")
, LWJGL3IFY("lwjgl3ify", "me.eigenraven.lwjgl3ify.core.Lwjgl3ifyCoremod", "lwjgl3ify")
@@ -0,0 +1,34 @@
package com.gtnewhorizons.angelica.mixins.early.angelica;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import net.minecraft.client.renderer.ActiveRenderInfo;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.Redirect;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import java.nio.FloatBuffer;
@Mixin(ActiveRenderInfo.class)
public class MixinActiveRenderInfo {
@Shadow private static FloatBuffer modelview;
@Shadow private static FloatBuffer projection;
@Inject(method = "updateRenderInfo", at = @At(value = "TAIL"))
private static void angelica$onUpdateRenderInfo(CallbackInfo ci) {
RenderingState.INSTANCE.setProjectionMatrix(projection);
RenderingState.INSTANCE.setModelViewMatrix(modelview);
}
@Redirect(method = "updateRenderInfo", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glGetInteger(ILjava/nio/IntBuffer;)V"), remap = false)
private static void angelica$glGetInteger(int pname, java.nio.IntBuffer params) {
if(pname == GL11.GL_VIEWPORT) {
GLStateManager.getViewportState().get(params);
} else {
GL11.glGetInteger(pname, params);
}
}
}
@@ -21,8 +21,5 @@ public abstract class MixinEntityRenderer {
viewEntity.lastTickPosY + (viewEntity.posY - viewEntity.lastTickPosY) * partialTicks,
viewEntity.lastTickPosZ + (viewEntity.posZ - viewEntity.lastTickPosZ) * partialTicks
);
RenderingState.INSTANCE.captureProjectionMatrix();
RenderingState.INSTANCE.captureModelViewMatrix();
}
}
@@ -16,7 +16,7 @@ public class MixinBlockFire {
private IIcon[] field_149850_M;
@Inject(method = "getFireIcon", at = @At("HEAD"))
private void hodgepodge$markFireAnimationForUpdate(int p_149840_1_, CallbackInfoReturnable<IIcon> cir) {
private void angelica$markFireAnimationForUpdate(int p_149840_1_, CallbackInfoReturnable<IIcon> cir) {
AnimationsRenderUtils.markBlockTextureForUpdate(field_149850_M[p_149840_1_]);
}
}
@@ -19,7 +19,7 @@ public class MixinMinecraftForgeClient {
* @author laetansky We can just mark any item texture that gets rendered for an update
*/
@Inject(method = "getItemRenderer", at = @At("HEAD"), remap = false)
private static void hodgepodge$beforeRenderItem(ItemStack itemStack, IItemRenderer.ItemRenderType type,
private static void angelica$beforeRenderItem(ItemStack itemStack, IItemRenderer.ItemRenderType type,
CallbackInfoReturnable<IItemRenderer> cir) {
final Item item = itemStack.getItem();
if (item.requiresMultipleRenderPasses()) {
@@ -22,7 +22,7 @@ public abstract class MixinRenderBlockFluid {
private IBlockAccess currentBlockAccess;
@Inject(method = "renderWorldBlock", at = @At(value = "HEAD"))
private void hodgepodge$saveCurrentBlockAccess(IBlockAccess world, int x, int y, int z, Block block, int modelId,
private void angelica$saveCurrentBlockAccess(IBlockAccess world, int x, int y, int z, Block block, int modelId,
RenderBlocks renderer, CallbackInfoReturnable<Boolean> cir) {
currentBlockAccess = world;
}
@@ -32,7 +32,7 @@ public class MixinRenderBlocks {
* visible (on the viewport) at the moment)
*/
@Inject(method = "*(Lnet/minecraft/block/Block;DDDLnet/minecraft/util/IIcon;)V", at = @At("HEAD"))
public void hodgepodge$beforeRenderFace(Block p_147761_1_, double p_147761_2_, double p_147761_4_,
public void angelica$beforeRenderFace(Block p_147761_1_, double p_147761_2_, double p_147761_4_,
double p_147761_6_, IIcon icon, CallbackInfo ci) {
if (overrideBlockTexture != null) {
icon = overrideBlockTexture;
@@ -42,14 +42,14 @@ public class MixinRenderBlocks {
}
@Inject(method = "renderBlockFire", at = @At("HEAD"))
public void hodgepodge$markFireBlockAnimationForUpdate(BlockFire instance, int x, int y, int z,
public void angelica$markFireBlockAnimationForUpdate(BlockFire instance, int x, int y, int z,
CallbackInfoReturnable<Boolean> cir) {
AnimationsRenderUtils.markBlockTextureForUpdate(instance.getFireIcon(0), blockAccess);
AnimationsRenderUtils.markBlockTextureForUpdate(instance.getFireIcon(1), blockAccess);
}
@ModifyVariable(method = "renderBlockLiquid", at = @At(value = "INVOKE_ASSIGN", target = "Lnet/minecraft/client/renderer/RenderBlocks;getBlockIconFromSideAndMetadata(Lnet/minecraft/block/Block;II)Lnet/minecraft/util/IIcon;"))
public IIcon hodgepodge$markFluidAnimationForUpdate(IIcon icon) {
public IIcon angelica$markFluidAnimationForUpdate(IIcon icon) {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
return icon;
@@ -16,7 +16,7 @@ public class MixinRenderItem {
* Some mods may call it to render their internally stored icons, so we make sure we mark those for an update
*/
@Inject(method = "renderIcon", at = @At("HEAD"))
private void hodgepodge$beforeRenderIcon(int p_94149_1_, int p_94149_2_, IIcon icon, int p_94149_4_, int p_94149_5_,
private void angelica$beforeRenderIcon(int p_94149_1_, int p_94149_2_, IIcon icon, int p_94149_4_, int p_94149_5_,
CallbackInfo ci) {
if (icon instanceof TextureAtlasSprite) {
((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
@@ -25,13 +25,13 @@ public class MixinWorldRenderer implements ITexturesCache {
private Set<IIcon> renderedIcons;
@ModifyArg(method = "updateRenderer", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderBlocks;<init>(Lnet/minecraft/world/IBlockAccess;)V"))
private IBlockAccess hodgepodge$onUpdateRenderer(IBlockAccess chunkCache) {
private IBlockAccess angelica$onUpdateRenderer(IBlockAccess chunkCache) {
renderedIcons = ((ITexturesCache) chunkCache).getRenderedTextures();
return chunkCache;
}
@Inject(method = "getGLCallListForPass", at = @At("HEAD"))
private void hodgepodge$getGLCallListForPass(int pass, CallbackInfoReturnable<Integer> cir) {
private void angelica$getGLCallListForPass(int pass, CallbackInfoReturnable<Integer> cir) {
if (isInFrustum && pass == 0 && renderedIcons != null) {
for (IIcon icon : renderedIcons) {
((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
@@ -22,18 +22,18 @@ public abstract class MixinWorld_FixLightUpdateLag {
public abstract boolean doChunksNearChunkExist(int p_72873_1_, int p_72873_2_, int p_72873_3_, int p_72873_4_);
@ModifyConstant(method = "updateLightByType", constant = @Constant(intValue = 17, ordinal = 0))
public int hodgepodge$modifyRangeCheck1(int cst) {
public int angelica$modifyRangeCheck1(int cst) {
return 16;
}
@Inject(method = "updateLightByType", at = @At(value = "FIELD", target = "Lnet/minecraft/world/World;theProfiler:Lnet/minecraft/profiler/Profiler;", shift = At.Shift.BEFORE, ordinal = 0))
public void hodgepodge$modifyUpdateRange(EnumSkyBlock p_147463_1_, int x, int y, int z,
public void angelica$modifyUpdateRange(EnumSkyBlock p_147463_1_, int x, int y, int z,
CallbackInfoReturnable<Boolean> cir, @Share("updateRange") LocalIntRef updateRange) {
updateRange.set(this.doChunksNearChunkExist(x, y, z, 18) ? 17 : 15);
}
@ModifyConstant(method = "updateLightByType", constant = { @Constant(intValue = 17, ordinal = 1), @Constant(intValue = 17, ordinal = 2) })
public int hodgepodge$modifyRangeCheck2(int cst, @Share("updateRange") LocalIntRef updateRange) {
public int angelica$modifyRangeCheck2(int cst, @Share("updateRange") LocalIntRef updateRange) {
return updateRange.get();
}
}
@@ -0,0 +1,27 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.textures.ic2;
import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite;
import ic2.core.item.ItemFluidCell;
import ic2.core.item.RenderLiquidCell;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraftforge.client.IItemRenderer.ItemRenderType;
import net.minecraftforge.fluids.FluidStack;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.At.Shift;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
@Mixin(RenderLiquidCell.class)
public class MixinRenderLiquidCell {
@Inject(at = @At(ordinal = 0, remap = false, shift = Shift.AFTER, target = "Lorg/lwjgl/opengl/GL11;glColor3ub(BBB)V", value = "INVOKE"), locals = LocalCapture.CAPTURE_FAILSOFT, method = "renderItem", remap = false)
private void angelica$markNeedsAnimationUpdate(ItemRenderType type, ItemStack item, Object[] data, CallbackInfo ci, ItemFluidCell cell, IIcon icon, FluidStack fs, IIcon windowIcon, IIcon fluidicon) {
if (fluidicon instanceof TextureAtlasSprite) {
((IPatchedTextureAtlasSprite) fluidicon).markNeedsAnimationUpdate();
}
}
}
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.mixins.early.sodium.startup;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import net.coderbot.iris.Iris;
@@ -19,7 +20,7 @@ public class MixinInitDebug {
}
// Temp -- move this into common debug code
Iris.identifyCapabilities();
Iris.setDebug(true);
Iris.setDebug(AngelicaMod.lwjglDebug);
}
}
@@ -0,0 +1,19 @@
package com.gtnewhorizons.angelica.mixins.late.client.jabba;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(targets = "mcp.mobius.betterbarrels.client.render.TileEntityBaseRenderer")
public class MixinTileEntityBaseRenderer {
@Redirect(method="saveBoundTexture", at=@At(value="INVOKE", target="Lorg/lwjgl/opengl/GL11;glGetInteger(I)I"), remap=false)
private int glGetInteger(int pname) {
if(pname == GL11.GL_TEXTURE_BINDING_2D) {
return GLStateManager.getBoundTexture();
} else {
return GL11.glGetInteger(pname);
}
}
}
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.proxy;
import com.google.common.base.Objects;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
@@ -11,6 +12,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.eventhandler.EventPriority;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.gameevent.TickEvent;
import cpw.mods.fml.relauncher.ReflectionHelper;
import me.jellysquid.mods.sodium.client.SodiumDebugScreenHandler;
import net.coderbot.iris.Iris;
import net.coderbot.iris.client.IrisDebugScreenHandler;
@@ -32,6 +34,7 @@ import net.minecraftforge.common.MinecraftForge;
import java.lang.management.ManagementFactory;
import java.util.Locale;
import java.util.concurrent.ConcurrentHashMap;
public class ClientProxy extends CommonProxy {
@@ -62,7 +65,17 @@ public class ClientProxy extends CommonProxy {
@Override
public void postInit(FMLPostInitializationEvent event) {
// Nothing to do here (yet)
if (ModStatus.isLotrLoaded && AngelicaConfig.enableSodium && AngelicaConfig.fixLotrSodiumCompat) {
try {
Class<?> lotrRendering = Class.forName("lotr.common.coremod.LOTRReplacedMethods$BlockRendering");
ReflectionHelper.setPrivateValue(lotrRendering,null,new ConcurrentHashMap<>(),"naturalBlockClassTable");
ReflectionHelper.setPrivateValue(lotrRendering,null,new ConcurrentHashMap<>(),"naturalBlockTable");
ReflectionHelper.setPrivateValue(lotrRendering,null,new ConcurrentHashMap<>(),"cachedNaturalBlocks");
}
catch (ClassNotFoundException e) {
AngelicaTweaker.LOGGER.error("Could net replace LOTR handle render code with thread safe version");
}
}
}
float lastIntegratedTickTime;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.rendering;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import lombok.Getter;
import org.joml.Matrix4f;
import org.joml.Vector3d;
@@ -26,17 +27,14 @@ public class RenderingState {
cameraPosition.set(x, y, z);
}
public void captureProjectionMatrix() {
// Not very fast, but given we're not on 3.2+ core and are still using the opengl matrix stack, we don't have much alternative
projectionBuffer.position(0);
GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, projectionBuffer);
projectionMatrix.set(projectionBuffer);
public void setProjectionMatrix(FloatBuffer projection) {
projectionMatrix.set(projection);
projectionMatrix.get(0, projectionBuffer);
}
public void captureModelViewMatrix() {
modelViewBuffer.position(0);
GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, modelViewBuffer);
modelViewMatrix.set(modelViewBuffer);
public void setModelViewMatrix(FloatBuffer modelview) {
modelViewMatrix.set(modelview);
modelViewMatrix.get(0, modelViewBuffer);
}
}
@@ -0,0 +1,44 @@
package com.gtnewhorizons.angelica.transform;
import com.google.common.collect.ImmutableList;
import net.minecraft.launchwrapper.IClassTransformer;
import org.apache.commons.lang3.tuple.Pair;
import org.spongepowered.asm.lib.ClassReader;
import org.spongepowered.asm.lib.ClassWriter;
import org.spongepowered.asm.lib.tree.ClassNode;
import java.util.List;
public class BlockTransformer implements IClassTransformer {
public static final String BlockClass = "net/minecraft/block/Block";
private static final String BlockClassFriendly = BlockClass.replace('/', '.');
public 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")
);
/**
* Delete the global vanilla bounding box fields off the Block object. {@link RedirectorTransformer}
* replaces these with a thread-safe alternative.
*/
@Override
public byte[] transform(String name, String transformedName, byte[] basicClass) {
if(basicClass != null && transformedName.equals(BlockClassFriendly)) {
final ClassReader cr = new ClassReader(basicClass);
final ClassNode cn = new ClassNode();
cr.accept(cn, 0);
cn.fields.removeIf(node -> BlockBoundsFields.stream().anyMatch(pair -> node.name.equals(pair.getLeft()) || node.name.equals(pair.getRight())));
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
cn.accept(cw);
basicClass = cw.toByteArray();
}
return basicClass;
}
}
@@ -25,6 +25,7 @@ package com.gtnewhorizons.angelica.transform;
import org.objectweb.asm.Opcodes;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
/**
* Using this class to search for a (single) String reference is > 40 times faster than parsing a class with a ClassReader +
@@ -44,15 +45,17 @@ public class ClassConstantPoolParser {
private static final int HANDLE = 15;
private static final int INDY = 18;
private final byte[][] BYTES_TO_SEARCH;
private final ArrayList<byte[]> BYTES_TO_SEARCH;
public ClassConstantPoolParser(String... strings) {
BYTES_TO_SEARCH = new byte[strings.length][];
for (int i = 0; i < BYTES_TO_SEARCH.length; i++) {
BYTES_TO_SEARCH[i] = strings[i].getBytes(StandardCharsets.UTF_8);
BYTES_TO_SEARCH = new ArrayList<>(strings.length);
for (int i = 0; i < strings.length; i++) {
BYTES_TO_SEARCH.add(i, strings[i].getBytes(StandardCharsets.UTF_8));
}
}
public void addString(String string) {
BYTES_TO_SEARCH.add(string.getBytes(StandardCharsets.UTF_8));
}
/**
* Returns true if the constant pool of the class represented by this byte array contains one of the Strings we are looking
* for
@@ -66,10 +69,10 @@ public class ClassConstantPoolParser {
return false;
}
// parses the constant pool
int n = readUnsignedShort(8, basicClass);
final int n = readUnsignedShort(8, basicClass);
int index = 10;
for (int i = 1; i < n; ++i) {
int size;
final int size;
switch (basicClass[index]) {
case FIELD:
case METH:
@@ -88,15 +91,18 @@ public class ClassConstantPoolParser {
case UTF8:
final int strLen = readUnsignedShort(index + 1, basicClass);
size = 3 + strLen;
label:
for (byte[] bytes : BYTES_TO_SEARCH) {
if (strLen == bytes.length) {
boolean found = true;
for (int j = index + 3; j < index + 3 + strLen; j++) {
if (basicClass[j] != bytes[j - (index + 3)]) {
break label;
found = false;
break;
}
}
return true;
if (found) {
return true;
}
}
}
break;
@@ -26,10 +26,15 @@ import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import static com.gtnewhorizons.angelica.transform.BlockTransformer.*;
/**
* This transformer redirects all Tessellator.instance field accesses to go through our TessellatorManager.
@@ -44,11 +49,12 @@ public class RedirectorTransformer implements IClassTransformer {
private static final String GL11 = "org/lwjgl/opengl/GL11";
private static final String GL13 = "org/lwjgl/opengl/GL13";
private static final String GL14 = "org/lwjgl/opengl/GL14";
private static final String Project = "org/lwjgl/util/glu/Project";
private static final String OpenGlHelper = "net/minecraft/client/renderer/OpenGlHelper";
private static final String EXTBlendFunc = "org/lwjgl/opengl/EXTBlendFuncSeparate";
private static final String ARBMultiTexture = "org/lwjgl/opengl/ARBMultitexture";
private static final String TessellatorClass = "net/minecraft/client/renderer/Tessellator";
private static final String BlockClass = "net/minecraft/block/Block";
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";
@@ -57,16 +63,8 @@ public class RedirectorTransformer implements IClassTransformer {
"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")
);
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, TessellatorClass, BlockClass);
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, TessellatorClass, BlockClass,
Project);
private static final Map<String, Map<String, String>> methodRedirects = new HashMap<>();
private static final Map<Integer, String> glCapRedirects = new HashMap<>();
private static final List<String> TransformerExclusions = Arrays.asList(
@@ -77,6 +75,10 @@ public class RedirectorTransformer implements IClassTransformer {
);
private static int remaps = 0;
private static final Set<String> blockSubclasses = 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<>());
static {
glCapRedirects.put(org.lwjgl.opengl.GL11.GL_ALPHA_TEST, "AlphaTest");
glCapRedirects.put(org.lwjgl.opengl.GL11.GL_BLEND, "Blend");
@@ -87,6 +89,7 @@ public class RedirectorTransformer implements IClassTransformer {
glCapRedirects.put(org.lwjgl.opengl.GL11.GL_FOG, "Fog");
glCapRedirects.put(org.lwjgl.opengl.GL12.GL_RESCALE_NORMAL, "RescaleNormal");
methodRedirects.put(GL11, RedirectMap.newMap()
.add("glGetFloat")
.add("glAlphaFunc")
.add("glBindTexture")
.add("glBlendFunc")
@@ -113,6 +116,20 @@ public class RedirectorTransformer implements IClassTransformer {
.add("glPopAttrib")
.add("glShadeModel")
.add("glTexImage2D")
.add("glMatrixMode")
.add("glLoadIdentity")
.add("glTranslatef")
.add("glTranslated")
.add("glScalef")
.add("glScaled")
.add("glMultMatrix")
.add("glRotatef")
.add("glRotated")
.add("glOrtho")
.add("glFrustum")
.add("glPushMatrix")
.add("glPopMatrix")
.add("glViewport")
);
methodRedirects.put(GL13, RedirectMap.newMap().add("glActiveTexture"));
methodRedirects.put(GL14, RedirectMap.newMap().add("glBlendFuncSeparate", "tryBlendFuncSeparate"));
@@ -121,6 +138,8 @@ public class RedirectorTransformer implements IClassTransformer {
.add("func_148821_a", "tryBlendFuncSeparate"));
methodRedirects.put(EXTBlendFunc, RedirectMap.newMap().add("glBlendFuncSeparateEXT", "tryBlendFuncSeparate"));
methodRedirects.put(ARBMultiTexture, RedirectMap.newMap().add("glActiveTextureARB"));
methodRedirects.put(Project, RedirectMap.newMap().add("gluPerspective"));
blockSubclasses.add(BlockClass);
}
@Override
@@ -143,6 +162,32 @@ public class RedirectorTransformer implements IClassTransformer {
final ClassNode cn = new ClassNode();
cr.accept(cn, 0);
// Track subclasses of Block
if (blockSubclasses.contains(cn.superName)) {
blockSubclasses.add(cn.name);
cstPoolParser.addString(cn.name);
}
// Check if this class shadows any fields of the parent class
if(blockSubclasses.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(cn.name.equals(BlockClass)) {
doWeShadow = false; // by definition
} else if(blockOwnerExclusions.contains(cn.superName)) {
doWeShadow = true;
} else {
// Check if we declare any known field names
Set<String> fieldsDeclaredByClass = cn.fields.stream().map(f -> f.name).collect(Collectors.toSet());
doWeShadow = BlockBoundsFields.stream().anyMatch(pair -> fieldsDeclaredByClass.contains(pair.getLeft()) || fieldsDeclaredByClass.contains(pair.getRight()));
}
if(doWeShadow) {
AngelicaTweaker.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"))) {
@@ -216,7 +261,7 @@ public class RedirectorTransformer implements IClassTransformer {
}
}
else if ((node.getOpcode() == Opcodes.GETFIELD || node.getOpcode() == Opcodes.PUTFIELD) && node instanceof FieldInsnNode fNode) {
if(fNode.owner.equals(BlockClass)) {
if(!blockOwnerExclusions.contains(fNode.owner) && blockSubclasses.contains(fNode.owner)) {
Pair<String, String> fieldToRedirect = null;
for(Pair<String, String> blockPairs : BlockBoundsFields) {
if(fNode.name.equals(blockPairs.getLeft()) || fNode.name.equals(blockPairs.getRight())) {
@@ -11,24 +11,24 @@ public class FogHelper {
public static float red, green, blue;
public static float getFogEnd() {
return GLStateManager.getFogState().end;
return GLStateManager.getFogState().getEnd();
}
public static float getFogStart() {
return GLStateManager.getFogState().start;
return GLStateManager.getFogState().getStart();
}
public static float getFogDensity() {
return GLStateManager.getFogState().density;
return GLStateManager.getFogState().getDensity();
}
/**
* Retrieves the current fog mode from the fixed-function pipeline.
*/
public static ChunkFogMode getFogMode() {
int mode = GLStateManager.getFogState().fogMode;
final int mode = GLStateManager.getFogState().getFogMode();
if(mode == 0 || !GLStateManager.getFogState().mode.isEnabled())
if(mode == 0 || !GLStateManager.getFogMode().isEnabled())
return ChunkFogMode.NONE;
return switch (mode) {
@@ -39,7 +39,7 @@ public class FogHelper {
}
public static float getFogCutoff() {
int mode = GLStateManager.getFogState().fogMode;
int mode = GLStateManager.getFogState().getFogMode();
return switch (mode) {
case GL11.GL_LINEAR -> getFogEnd();
@@ -8,12 +8,14 @@ import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL30;
import java.util.Arrays;
import java.util.EnumSet;
public class GlStateTracker {
private static final int UNASSIGNED_HANDLE = -1;
private final int[] bufferState = new int[GlBufferTarget.COUNT];
//private final int[] bufferRestoreState = new int[GlBufferTarget.COUNT];
private final EnumSet<GlBufferTarget> mutatedBuffers = EnumSet.noneOf(GlBufferTarget.class);
private int vertexArrayState;
//private int vertexArrayRestoreState;
@@ -31,6 +33,8 @@ public class GlStateTracker {
this.bufferState[target.ordinal()] = buffer;
mutatedBuffers.add(target);
return prevBuffer != buffer;
}
@@ -47,9 +51,10 @@ public class GlStateTracker {
}
public void applyRestoreState() {
for (int i = 0; i < GlBufferTarget.COUNT; i++) {
GL15.glBindBuffer(GlBufferTarget.VALUES[i].getTargetParameter(), 0);
}
mutatedBuffers.forEach(target -> {
GL15.glBindBuffer(target.getTargetParameter(), 0);
});
mutatedBuffers.clear();
if(GlFunctions.isVertexArraySupported()) {
GL30.glBindVertexArray(0);
}
@@ -19,7 +19,7 @@ public class ModelVertexUtil {
* @return The resulting de-normalized unsigned short
*/
public static short denormalizeVertexTextureFloatAsShort(float value) {
return (short) (Math.min(0.99999997F, value) * 32768.0f);
return (short) (Math.round(value * 32768.0F) & 0xFFFF);
}
/**
@@ -229,7 +229,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
int baseY = this.render.getOriginY();
int baseZ = this.render.getOriginZ();
BlockPos renderOffset = this.offset;
RenderBlocks rb = new RenderBlocks(slice);
RenderBlocks rb = new RenderBlocks(slice.getWorld());
for (int relY = 0; relY < 16; relY++) {
if (cancellationSource.isCancelled()) {
return;
@@ -258,7 +258,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
long seed = MathUtil.hashPos(pos.x, pos.y, pos.z);
if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
if (cache.getBlockRenderer().renderModel(cache.getWorldSlice(), Tessellator.instance, rb, block, meta, pos, buffers.get(pass), true, seed)) {
if (cache.getBlockRenderer().renderModel(slice.getWorld(), Tessellator.instance, rb, block, meta, pos, buffers.get(pass), true, seed)) {
bounds.addBlock(relX, relY, relZ);
}
}
@@ -355,4 +355,8 @@ public class WorldSlice implements IBlockAccess {
case UNKNOWN -> 1.0f;
};
}
public World getWorld() {
return this.world;
}
}
@@ -1,6 +1,8 @@
package me.jellysquid.mods.sodium.client.world.cloned;
import com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook;
import com.gtnewhorizons.angelica.compat.ExtendedBlockStorageExt;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
@@ -56,9 +58,15 @@ public class ClonedChunkSection {
}
this.pos = pos;
this.data = new ExtendedBlockStorageExt(section);
this.data = new ExtendedBlockStorageExt(chunk, section);
this.biomeData = new BiomeGenBase[chunk.getBiomeArray().length];
int bArrLength;
if (ModStatus.isEIDBiomeLoaded) {
bArrLength = ((ChunkBiomeHook)chunk).getBiomeShortArray().length;
} else {
bArrLength = chunk.getBiomeArray().length;
}
this.biomeData = new BiomeGenBase[bArrLength];
StructureBoundingBox box = new StructureBoundingBox(pos.getMinX(), pos.getMinY(), pos.getMinZ(), pos.getMaxX(), pos.getMaxY(), pos.getMaxZ());
@@ -39,17 +39,17 @@ public class IrisRenderSystem {
}
hasMultibind = Iris.capabilities.OpenGL45;
} catch (Exception ignored) {}
} catch (NoSuchFieldError ignored) {}
try {
if (dsaState == null && Iris.capabilities.GL_ARB_direct_state_access) {
dsaState = new DSAARB();
Iris.logger.info("ARB_direct_state_access detected, enabling DSA.");
}
} catch (Exception ignored) {}
} catch (NoSuchFieldError ignored) {}
try {
hasMultibind |= Iris.capabilities.GL_ARB_multi_bind;
} catch (Exception ignored) {}
} catch (NoSuchFieldError ignored) {}
supportsCompute = supportsCompute();
}
@@ -243,8 +243,7 @@ public class IrisRenderSystem {
public static void setupProjectionMatrix(Matrix4f matrix) {
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glPushMatrix();
PROJECTION_MATRIX_BUFFER.clear().rewind();
matrix.get(PROJECTION_MATRIX_BUFFER);
matrix.get(0, PROJECTION_MATRIX_BUFFER);
GL11.glLoadMatrix(PROJECTION_MATRIX_BUFFER);
GL11.glMatrixMode(GL11.GL_MODELVIEW);
}
@@ -15,8 +15,8 @@ public class AlphaTestStorage {
final AlphaState alphaState = GLStateManager.getAlphaState();
// Only save the previous state if the alpha test wasn't already locked
originalAlphaTestEnable = alphaState.mode.isEnabled();
originalAlphaTest = new AlphaTest(AlphaTestFunction.fromGlId(alphaState.function).orElse(AlphaTestFunction.ALWAYS), alphaState.reference);
originalAlphaTestEnable = GLStateManager.getAlphaTest().isEnabled();
originalAlphaTest = new AlphaTest(AlphaTestFunction.fromGlId(alphaState.getFunction()).orElse(AlphaTestFunction.ALWAYS), alphaState.getReference());
}
alphaTestLocked = false;
@@ -1,24 +1,24 @@
package net.coderbot.iris.gl.blending;
import com.gtnewhorizons.angelica.glsm.states.DepthState;
import com.gtnewhorizons.angelica.glsm.states.GLColorMask;
import com.gtnewhorizons.angelica.glsm.states.ColorMask;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import lombok.Getter;
public class DepthColorStorage {
private static boolean originalDepthEnable;
private static ColorMask originalColor;
private static net.coderbot.iris.gl.blending.ColorMask originalColor;
@Getter
private static boolean depthColorLocked;
public static void disableDepthColor() {
if (!depthColorLocked) {
// Only save the previous state if the depth and color mask wasn't already locked
GLColorMask colorMask = GLStateManager.getColorMask();
ColorMask colorMask = GLStateManager.getColorMask();
final DepthState depthState = GLStateManager.getDepthState();
originalDepthEnable = depthState.mask;
originalColor = new ColorMask(colorMask.red, colorMask.green, colorMask.blue, colorMask.alpha);
originalDepthEnable = depthState.isMask();
originalColor = new net.coderbot.iris.gl.blending.ColorMask(colorMask.red, colorMask.green, colorMask.blue, colorMask.alpha);
}
depthColorLocked = false;
@@ -34,7 +34,7 @@ public class DepthColorStorage {
}
public static void deferColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
originalColor = new ColorMask(red, green, blue, alpha);
originalColor = new net.coderbot.iris.gl.blending.ColorMask(red, green, blue, alpha);
}
public static void unlockDepthColor() {
@@ -46,7 +46,7 @@ public class ProgramSamplers {
// We need to keep the active texture intact, since if we mess it up
// in the middle of RenderType setup, bad things will happen.
int activeTexture = GLStateManager.getActiveTexture();
int activeTexture = GLStateManager.getActiveTextureUnit();
for (SamplerBinding samplerBinding : samplerBindings) {
samplerBinding.update();
@@ -1,11 +1,5 @@
package net.coderbot.iris.gui;
import org.jetbrains.annotations.Nullable;
import org.lwjgl.PointerBuffer;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@@ -512,10 +512,10 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
case TERRAIN_SOLID, TERRAIN_CUTOUT, TERRAIN_CUTOUT_MIPPED:
return RenderCondition.TERRAIN_OPAQUE;
case ENTITIES:
if (GLStateManager.getBlendState().srcRgb == SRC_ALPHA &&
GLStateManager.getBlendState().srcAlpha == ONE_MINUS_SRC_ALPHA &&
GLStateManager.getBlendState().dstRgb == ONE &&
GLStateManager.getBlendState().dstAlpha == ONE_MINUS_SRC_ALPHA)
if (GLStateManager.getBlendState().getSrcRgb() == SRC_ALPHA &&
GLStateManager.getBlendState().getSrcAlpha() == ONE_MINUS_SRC_ALPHA &&
GLStateManager.getBlendState().getDstRgb() == ONE &&
GLStateManager.getBlendState().getDstAlpha() == ONE_MINUS_SRC_ALPHA)
{
return RenderCondition.ENTITIES_TRANSLUCENT;
} else {
@@ -39,7 +39,7 @@ public class TextureTracker {
if (lockBindCallback) {
return;
}
if (GLStateManager.getActiveTexture() == 0) {
if (GLStateManager.getActiveTextureUnit() == 0) {
lockBindCallback = true;
if (bindTextureListener != null) {
bindTextureListener.run();
@@ -61,7 +61,7 @@ public final class CommonUniforms {
// TODO: OptiFine doesn't think that atlasSize is a "dynamic" uniform,
// but we do. How will custom uniforms depending on atlasSize work?
uniforms.uniform2i("atlasSize", () -> {
final int glId = GLStateManager.getTextures()[0].binding;
final int glId = GLStateManager.getBoundTexture();
final AbstractTexture texture = TextureTracker.INSTANCE.getTexture(glId);
if (texture instanceof TextureMap) {
@@ -73,7 +73,7 @@ public final class CommonUniforms {
}, StateUpdateNotifiers.bindTextureNotifier);
uniforms.uniform2i("gtextureSize", () -> {
final int glId = GLStateManager.getTextures()[0].binding;
final int glId = GLStateManager.getBoundTexture();
final TextureInfoCache.TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
return new Vector2i(info.getWidth(), info.getHeight());
@@ -81,9 +81,9 @@ public final class CommonUniforms {
}, StateUpdateNotifiers.bindTextureNotifier);
uniforms.uniform4i("blendFunc", () -> {
final BlendState blend = GLStateManager.getBlendState();
if(blend.mode.isEnabled()) {
return new Vector4i(blend.srcRgb, blend.dstRgb, blend.srcAlpha, blend.dstAlpha);
if(GLStateManager.getBlendMode().isEnabled()) {
final BlendState blend = GLStateManager.getBlendState();
return new Vector4i(blend.getSrcRgb(), blend.getDstRgb(), blend.getSrcAlpha(), blend.getDstAlpha());
}
return ZERO_VECTOR_4i;
}, StateUpdateNotifiers.blendFuncNotifier);
@@ -11,25 +11,25 @@ public class FogUniforms {
public static void addFogUniforms(DynamicUniformHolder uniforms) {
uniforms.uniform1i("fogMode", () -> {
if(!GLStateManager.getFogState().mode.isEnabled()) return 0;
if(!GLStateManager.getFogMode().isEnabled()) return 0;
return GLStateManager.getFogState().fogMode;
return GLStateManager.getFogState().getFogMode();
}, listener -> {
StateUpdateNotifiers.fogToggleNotifier.setListener(listener);
StateUpdateNotifiers.fogModeNotifier.setListener(listener);
});
uniforms.uniform1f("fogDensity", () -> GLStateManager.getFogState().density, listener -> {
uniforms.uniform1f("fogDensity", () -> GLStateManager.getFogState().getDensity(), listener -> {
StateUpdateNotifiers.fogToggleNotifier.setListener(listener);
StateUpdateNotifiers.fogDensityNotifier.setListener(listener);
});
uniforms.uniform1f("fogStart", () -> GLStateManager.getFogState().start, listener -> {
uniforms.uniform1f("fogStart", () -> GLStateManager.getFogState().getStart(), listener -> {
StateUpdateNotifiers.fogToggleNotifier.setListener(listener);
StateUpdateNotifiers.fogStartNotifier.setListener(listener);
});
uniforms.uniform1f("fogEnd", () -> GLStateManager.getFogState().end, listener -> {
uniforms.uniform1f("fogEnd", () -> GLStateManager.getFogState().getEnd(), listener -> {
StateUpdateNotifiers.fogToggleNotifier.setListener(listener);
StateUpdateNotifiers.fogEndNotifier.setListener(listener);
});