mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-21 04:42:17 +00:00
Compare commits
37
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4fabe45ae7 | ||
|
|
ab54359f03 | ||
|
|
0c9ec5b23a | ||
|
|
20ae68aa62 | ||
|
|
46164ebac7 | ||
|
|
de0a600163 | ||
|
|
956f9e344e | ||
|
|
acc1f58778 | ||
|
|
1a38bd1a00 | ||
|
|
cfc19bb35e | ||
|
|
446c8e74ee | ||
|
|
74cdc561e6 | ||
|
|
67fbcc8ff0 | ||
|
|
d19b8d5302 | ||
|
|
ae0e03bead | ||
|
|
7d7d73a48f | ||
|
|
6dcc4649db | ||
|
|
5db5c7f683 | ||
|
|
21b9b8cb3f | ||
|
|
fc520de642 | ||
|
|
9916075569 | ||
|
|
6624a9adb3 | ||
|
|
c3216007c1 | ||
|
|
92b22b1827 | ||
|
|
f32c14f795 | ||
|
|
ef15577b15 | ||
|
|
ac60c01788 | ||
|
|
9410902937 | ||
|
|
52776530d8 | ||
|
|
9cebb352ad | ||
|
|
d810eaf876 | ||
|
|
1a1ca32721 | ||
|
|
a3d689e806 | ||
|
|
d4e22b6c0c | ||
|
|
7e24f6a395 | ||
|
|
c8e6a6f34f | ||
|
|
f7a79cf02f |
No files matched your search
@@ -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
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
package com.gtnewhorizons.angelica.client.renderer;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.compat.nd.RecyclingList;
|
||||
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.List;
|
||||
|
||||
/*
|
||||
* To be used in conjunction with the TessellatorManager
|
||||
*
|
||||
* Used to capture the quads generated by the Tessellator across multiple draw calls and make the quad
|
||||
* list available for usage.
|
||||
*
|
||||
* NOTE: This will _not_ (currently) capture, integrate, or stop any GL calls made around the tessellator draw calls.
|
||||
*
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public class CapturingTessellator extends Tessellator {
|
||||
private final BlockRenderer.Flags FLAGS = new BlockRenderer.Flags(true, true, true, true);
|
||||
private final RecyclingList<Quad> quadBuf = new RecyclingList<>(Quad::new);
|
||||
|
||||
// Any offset we need to the Tesselator's offset!
|
||||
private final BlockPos offset = new BlockPos();
|
||||
|
||||
public void setOffset(BlockPos pos) {
|
||||
this.offset.set(pos);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int draw() {
|
||||
// Adapted from Neodymium
|
||||
|
||||
FLAGS.hasBrightness = this.hasBrightness;
|
||||
FLAGS.hasColor = this.hasColor;
|
||||
FLAGS.hasNormals = this.hasNormals;
|
||||
|
||||
// TODO: Support GL_TRIANGLES
|
||||
if(this.drawMode != GL11.GL_QUADS) {
|
||||
throw new IllegalStateException("Currently only supports GL_QUADS");
|
||||
|
||||
}
|
||||
final int verticesPerPrimitive = this.drawMode == GL11.GL_QUADS ? 4 : 3;
|
||||
|
||||
|
||||
for(int quadI = 0; quadI < this.vertexCount / verticesPerPrimitive; quadI++) {
|
||||
final Quad quad = quadBuf.next();
|
||||
quad.setState(this.rawBuffer, quadI * (verticesPerPrimitive * 8), FLAGS, this.drawMode, -offset.x, -offset.y, -offset.z);
|
||||
|
||||
if(quad.deleted) {
|
||||
quadBuf.remove();
|
||||
}
|
||||
}
|
||||
|
||||
final int i = this.rawBufferIndex * 4;
|
||||
this.reset();
|
||||
this.isDrawing = false;
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reset() {
|
||||
super.reset();
|
||||
this.offset.zero();
|
||||
}
|
||||
|
||||
public List<Quad> getQuads() {
|
||||
return quadBuf.getAsList();
|
||||
}
|
||||
|
||||
public void clearQuads() {
|
||||
this.quadBuf.reset();
|
||||
}
|
||||
|
||||
public static ByteBuffer quadsToBuffer(List<Quad> quads, VertexFormat format) {
|
||||
if(!format.canWriteQuads()) {
|
||||
throw new IllegalStateException("Vertex format has no quad writer: " + format);
|
||||
}
|
||||
final ByteBuffer byteBuffer = BufferUtils.createByteBuffer(format.getVertexSize() * quads.size() * 4);
|
||||
// noinspection ForLoopReplaceableByForEach
|
||||
for (int i = 0, quadsSize = quads.size(); i < quadsSize; i++) {
|
||||
format.writeQuad(quads.get(i), byteBuffer);
|
||||
}
|
||||
byteBuffer.rewind();
|
||||
return byteBuffer;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
+17
-13
@@ -1,32 +1,36 @@
|
||||
package com.gtnewhorizons.angelica.compat.toremove;
|
||||
package com.gtnewhorizons.angelica.compat.mojang;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormatElement;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormatElement.Type;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormatElement.Usage;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.nd.writers.ItemVBOQuadWriter;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
|
||||
public class DefaultVertexFormat {
|
||||
|
||||
public static final VertexFormatElement POSITION_ELEMENT = new VertexFormatElement(0, Type.FLOAT, Usage.POSITION, 3);
|
||||
public static final VertexFormatElement COLOR_ELEMENT = new VertexFormatElement(0, Type.UBYTE, Usage.COLOR, 4);
|
||||
public static final VertexFormatElement TEXTURE_0_ELEMENT = new VertexFormatElement(0, Type.FLOAT, Usage.UV, 2);
|
||||
public static final VertexFormatElement TEXTURE_ELEMENT = new VertexFormatElement(OpenGlHelper.defaultTexUnit, Type.FLOAT, Usage.UV, 2);
|
||||
public static final VertexFormatElement LIGHT_ELEMENT = new VertexFormatElement(OpenGlHelper.lightmapTexUnit, Type.SHORT, Usage.UV, 2);
|
||||
// TODO: The overlay element index is wrong, need to find a 1.7.10 equivalent
|
||||
public static final VertexFormatElement OVERLAY_ELEMENT = new VertexFormatElement(1, Type.SHORT, Usage.UV, 2);
|
||||
public static final VertexFormatElement LIGHT_ELEMENT = new VertexFormatElement(2, Type.SHORT, Usage.UV, 2);
|
||||
public static final VertexFormatElement NORMAL_ELEMENT = new VertexFormatElement(0, Type.BYTE, Usage.NORMAL, 3);
|
||||
public static final VertexFormatElement PADDING_ELEMENT = new VertexFormatElement(0, Type.BYTE, Usage.PADDING, 1);
|
||||
public static final VertexFormat POSITION_COLOR_TEXTURE_LIGHT_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_0_ELEMENT).add(LIGHT_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_0_ELEMENT).add(OVERLAY_ELEMENT).add(LIGHT_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_COLOR_LIGHT = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_0_ELEMENT).add(COLOR_ELEMENT).add(LIGHT_ELEMENT).build());
|
||||
public static final VertexFormat ITEM_VBO = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build(), new ItemVBOQuadWriter());
|
||||
public static final VertexFormat POSITION_COLOR_TEXTURE_LIGHT_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).add(LIGHT_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).add(OVERLAY_ELEMENT).add(LIGHT_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_COLOR_LIGHT = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(COLOR_ELEMENT).add(LIGHT_ELEMENT).build());
|
||||
public static final VertexFormat POSITION = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_LIGHT = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(LIGHT_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_0_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_TEXTURE = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_0_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_0_ELEMENT).add(COLOR_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_TEX_LIGHTMAP = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_0_ELEMENT).add(LIGHT_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_LIGHT_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_0_ELEMENT).add(LIGHT_ELEMENT).add(COLOR_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_COLOR_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_0_ELEMENT).add(COLOR_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_TEXTURE = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(COLOR_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_COLOR_TEX_LIGHTMAP = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).add(LIGHT_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_LIGHT_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(LIGHT_ELEMENT).add(COLOR_ELEMENT).build());
|
||||
public static final VertexFormat POSITION_TEXTURE_COLOR_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(COLOR_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
|
||||
|
||||
|
||||
}
|
||||
@@ -1,5 +1,8 @@
|
||||
package com.gtnewhorizons.angelica.compat.mojang;
|
||||
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
|
||||
@@ -23,6 +26,47 @@ public class VertexBuffer implements AutoCloseable {
|
||||
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
public void upload(Tessellator tessellator, VertexFormat format) {
|
||||
try {
|
||||
this.upload(tessellatorToBuffer(tessellator, format), tessellator.vertexCount);
|
||||
} catch(Exception e) {
|
||||
throw new RuntimeException("Failed to upload vertex buffer", e);
|
||||
} finally {
|
||||
((ITessellatorInstance) tessellator).discard();
|
||||
}
|
||||
}
|
||||
|
||||
public ByteBuffer tessellatorToBuffer(Tessellator tessellator, VertexFormat format) {
|
||||
|
||||
final int verticesPerPrimitive = tessellator.drawMode == GL11.GL_QUADS ? 4 : 3;
|
||||
|
||||
final int[] rawBuffer = tessellator.rawBuffer;
|
||||
final int byteSize = format.getVertexSize() * tessellator.vertexCount;
|
||||
final ByteBuffer byteBuffer = BufferUtils.createByteBuffer(byteSize);
|
||||
|
||||
|
||||
|
||||
for(int quadI = 0 ; quadI < tessellator.vertexCount / verticesPerPrimitive ; quadI++) {
|
||||
for(int vertexI = 0 ; vertexI < 4 ; vertexI++) {
|
||||
final int i = (quadI * 4 * 8 ) + (vertexI * 8);
|
||||
|
||||
// Position
|
||||
byteBuffer.putFloat(Float.intBitsToFloat(rawBuffer[i + 0]));
|
||||
byteBuffer.putFloat(Float.intBitsToFloat(rawBuffer[i + 1]));
|
||||
byteBuffer.putFloat(Float.intBitsToFloat(rawBuffer[i + 2]));
|
||||
|
||||
// Texture
|
||||
byteBuffer.putFloat(Float.intBitsToFloat(rawBuffer[i + 3]));
|
||||
byteBuffer.putFloat(Float.intBitsToFloat(rawBuffer[i + 4]));
|
||||
|
||||
// Normals
|
||||
byteBuffer.putInt(rawBuffer[i + 6]);
|
||||
}
|
||||
}
|
||||
|
||||
return (ByteBuffer) byteBuffer.rewind();
|
||||
}
|
||||
|
||||
public void upload(ByteBuffer buffer, int vertexCount) {
|
||||
if (this.id == -1) return;
|
||||
this.vertexCount = vertexCount;
|
||||
@@ -42,7 +86,11 @@ public class VertexBuffer implements AutoCloseable {
|
||||
GL11.glPushMatrix();
|
||||
GL11.glLoadIdentity();
|
||||
GL11.glMultMatrix(floatBuffer);
|
||||
GL11.glDrawArrays(mode, 0, this.vertexCount);
|
||||
draw(mode);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
public void draw(int mode) {
|
||||
GL11.glDrawArrays(mode, 0, this.vertexCount);
|
||||
}
|
||||
}
|
||||
+22
-5
@@ -1,7 +1,8 @@
|
||||
package com.gtnewhorizons.angelica.compat.toremove;
|
||||
package com.gtnewhorizons.angelica.compat.mojang;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormatElement;
|
||||
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import it.unimi.dsi.fastutil.ints.IntArrayList;
|
||||
import it.unimi.dsi.fastutil.ints.IntList;
|
||||
import lombok.Getter;
|
||||
@@ -9,6 +10,7 @@ import net.coderbot.iris.block_rendering.BlockRenderingSettings;
|
||||
import net.coderbot.iris.vertices.ImmediateState;
|
||||
import net.coderbot.iris.vertices.IrisVertexFormats;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.List;
|
||||
|
||||
public class VertexFormat {
|
||||
@@ -18,7 +20,13 @@ public class VertexFormat {
|
||||
@Getter
|
||||
protected final int vertexSize;
|
||||
|
||||
protected IWriteQuads quadWriter;
|
||||
|
||||
public VertexFormat(ImmutableList<VertexFormatElement> elements) {
|
||||
this(elements, null);
|
||||
}
|
||||
|
||||
public VertexFormat(ImmutableList<VertexFormatElement> elements, IWriteQuads quadWriter) {
|
||||
this.elements = elements;
|
||||
int i = 0;
|
||||
for (VertexFormatElement element : elements) {
|
||||
@@ -26,9 +34,9 @@ public class VertexFormat {
|
||||
i += element.getByteSize();
|
||||
}
|
||||
vertexSize = i;
|
||||
this.quadWriter = quadWriter;
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public void setupBufferState(long l) {
|
||||
if (BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat() && ImmediateState.renderWithExtendedVertexFormat) {
|
||||
if (this == DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL || this == DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP) {
|
||||
@@ -44,11 +52,10 @@ public class VertexFormat {
|
||||
final List<VertexFormatElement> list = this.getElements();
|
||||
|
||||
for(int j = 0; j < list.size(); ++j) {
|
||||
((VertexFormatElement)list.get(j)).setupBufferState(l + (long)this.offsets.getInt(j), i);
|
||||
list.get(j).setupBufferState(l + this.offsets.getInt(j), i);
|
||||
}
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public void clearBufferState() {
|
||||
if (BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat() && ImmediateState.renderWithExtendedVertexFormat) {
|
||||
if (this == DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL || this == DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP) {
|
||||
@@ -64,4 +71,14 @@ public class VertexFormat {
|
||||
}
|
||||
}
|
||||
|
||||
public boolean canWriteQuads() {
|
||||
return quadWriter != null;
|
||||
}
|
||||
|
||||
public void writeQuad(Quad quad, ByteBuffer byteBuffer) {
|
||||
if(quadWriter == null) {
|
||||
throw new IllegalStateException("No quad writer set");
|
||||
}
|
||||
quadWriter.writeQuad(quad, byteBuffer);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.compat.nd;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
public interface IWriteQuads {
|
||||
void writeQuad(Quad quad, ByteBuffer buf);
|
||||
}
|
||||
@@ -31,7 +31,8 @@ public class Quad implements ModelQuadView {
|
||||
public float[] vs = new float[4];
|
||||
public int[] bs = new int[4];
|
||||
public int[] cs = new int[4];
|
||||
// TODO normals?
|
||||
public int[] ns = new int[4];
|
||||
|
||||
public boolean deleted;
|
||||
|
||||
public ModelQuadFacing normal;
|
||||
@@ -51,6 +52,7 @@ public class Quad implements ModelQuadView {
|
||||
|
||||
private boolean hasColor;
|
||||
private boolean hasShade;
|
||||
private boolean hasNormals;
|
||||
|
||||
public boolean hasColor() {
|
||||
return this.hasColor;
|
||||
@@ -64,6 +66,10 @@ public class Quad implements ModelQuadView {
|
||||
return this.hasShade;
|
||||
}
|
||||
|
||||
public boolean hasNormals() {
|
||||
return this.hasNormals;
|
||||
}
|
||||
|
||||
public ForgeDirection getFace() {
|
||||
// TODO: Sodium/Quad Facing
|
||||
return ForgeDirection.UP;
|
||||
@@ -111,7 +117,7 @@ public class Quad implements ModelQuadView {
|
||||
|
||||
@Override
|
||||
public int getNormal(int idx) {
|
||||
return 0;
|
||||
return ns[idx];
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -136,10 +142,14 @@ public class Quad implements ModelQuadView {
|
||||
us[vi] = Float.intBitsToFloat(rawBuffer[i + 3]);
|
||||
vs[vi] = Float.intBitsToFloat(rawBuffer[i + 4]);
|
||||
|
||||
bs[vi] = flags.hasBrightness ? rawBuffer[i + 7] : DEFAULT_BRIGHTNESS;
|
||||
cs[vi] = flags.hasColor ? rawBuffer[i + 5] : DEFAULT_COLOR;
|
||||
ns[vi] = flags.hasNormals ? rawBuffer[i + 6] : 0;
|
||||
bs[vi] = flags.hasBrightness ? rawBuffer[i + 7] : DEFAULT_BRIGHTNESS;
|
||||
|
||||
this.hasColor |= flags.hasColor;
|
||||
this.hasShade |= flags.hasBrightness;
|
||||
this.hasNormals |= flags.hasNormals;
|
||||
|
||||
|
||||
i += 8;
|
||||
}
|
||||
@@ -155,6 +165,7 @@ public class Quad implements ModelQuadView {
|
||||
|
||||
bs[3] = bs[2];
|
||||
cs[3] = cs[2];
|
||||
ns[3] = ns[2];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -205,39 +216,6 @@ public class Quad implements ModelQuadView {
|
||||
Arrays.fill(quadCountByDirection, 1);
|
||||
}
|
||||
|
||||
public void writeToBuffer(BufferWriter out) throws IOException {
|
||||
for(int vertexI = 0; vertexI < 4; vertexI++) {
|
||||
int vi = vertexI;
|
||||
int provokingI = 3;
|
||||
|
||||
float x = xs[vi];
|
||||
float y = ys[vi];
|
||||
float z = zs[vi];
|
||||
|
||||
out.writeFloat(x);
|
||||
out.writeFloat(y);
|
||||
out.writeFloat(z);
|
||||
|
||||
float u = us[vi];
|
||||
float v = vs[vi];
|
||||
|
||||
out.writeFloat(u);
|
||||
out.writeFloat(v);
|
||||
|
||||
int b = bs[vi];
|
||||
|
||||
out.writeInt(b);
|
||||
|
||||
int c = cs[vi];
|
||||
|
||||
out.writeInt(c);
|
||||
|
||||
assert out.position() % getStride() == 0;
|
||||
|
||||
//System.out.println("[" + vertexI + "] x: " + x + ", y: " + y + " z: " + z + ", u: " + u + ", v: " + v + ", b: " + b + ", c: " + c);
|
||||
}
|
||||
}
|
||||
|
||||
public int quadCountByUVDirection(boolean v) {
|
||||
if(v) {
|
||||
return quadCountByDirection[uDirectionIs01 ? 0 : 1];
|
||||
@@ -285,6 +263,7 @@ public class Quad implements ModelQuadView {
|
||||
vs[dest] = o.vs[src];
|
||||
bs[dest] = o.bs[src];
|
||||
cs[dest] = o.cs[src];
|
||||
ns[dest] = o.ns[src];
|
||||
|
||||
updateMinMaxXYZ(); // TODO isn't doing this a waste? I should get rid of the min/maxXYZ variables entirely.
|
||||
}
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
package com.gtnewhorizons.angelica.compat.nd.writers;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
public class ItemVBOQuadWriter implements IWriteQuads {
|
||||
private boolean direct;
|
||||
|
||||
public ItemVBOQuadWriter() {
|
||||
init(false);
|
||||
}
|
||||
|
||||
public void init(boolean direct) {
|
||||
// This would need to be re-initialized if the direct vs indirect changes
|
||||
this.direct = direct;
|
||||
}
|
||||
@Override
|
||||
public void writeQuad(Quad quad, ByteBuffer buf) {
|
||||
if(direct) {
|
||||
writeQuadDirect(quad, buf);
|
||||
} else {
|
||||
writeQuadIndirect(quad, buf);
|
||||
}
|
||||
}
|
||||
|
||||
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
|
||||
throw new UnsupportedOperationException("Direct mode not supported yet");
|
||||
}
|
||||
|
||||
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
|
||||
for(int idx = 0; idx < 4; ++idx) {
|
||||
// Position
|
||||
buf.putFloat(quad.getX(idx));
|
||||
buf.putFloat(quad.getY(idx));
|
||||
buf.putFloat(quad.getZ(idx));
|
||||
|
||||
// Texture
|
||||
buf.putFloat(quad.getTexU(idx));
|
||||
buf.putFloat(quad.getTexV(idx));
|
||||
|
||||
// Normals + Padding
|
||||
buf.putInt(quad.getNormal(idx));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.gtnewhorizons.angelica.compat.toremove;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import lombok.Getter;
|
||||
|
||||
@Deprecated
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
package com.gtnewhorizons.angelica.compat.toremove;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import it.unimi.dsi.fastutil.Hash;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
|
||||
import lombok.Getter;
|
||||
|
||||
@@ -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,70 @@ 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.joml.Vector3f;
|
||||
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 +110,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 +123,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 +160,24 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
|
||||
public static void glGetFloat(int pname, FloatBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
GL11.glGetFloat(pname, params);
|
||||
return;
|
||||
}
|
||||
|
||||
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 +188,7 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
hudCaching$blendEnabled = true;
|
||||
blendState.mode.enable();
|
||||
blendMode.enable();
|
||||
}
|
||||
|
||||
public static void disableBlend() {
|
||||
@@ -150,7 +199,7 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
hudCaching$blendEnabled = false;
|
||||
blendState.mode.disable();
|
||||
blendMode.disable();
|
||||
}
|
||||
|
||||
public static void glBlendFunc(int srcFactor, int dstFactor) {
|
||||
@@ -161,17 +210,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 +238,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 +253,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 +267,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 +343,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 +366,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 +394,7 @@ public class GLStateManager {
|
||||
return;
|
||||
}
|
||||
}
|
||||
alphaState.mode.enable();
|
||||
alphaTest.enable();
|
||||
}
|
||||
|
||||
public static void disableAlphaTest() {
|
||||
@@ -354,7 +404,7 @@ public class GLStateManager {
|
||||
return;
|
||||
}
|
||||
}
|
||||
alphaState.mode.disable();
|
||||
alphaTest.disable();
|
||||
}
|
||||
|
||||
public static void glAlphaFunc(int function, float reference) {
|
||||
@@ -364,41 +414,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 +495,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 +505,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 +529,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 +552,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 +587,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 +611,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 +632,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 +681,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 +693,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 +721,161 @@ 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);
|
||||
}
|
||||
|
||||
private static final Vector3f rotation = new Vector3f();
|
||||
public static void glRotatef(float angle, float x, float y, float z) {
|
||||
GL11.glRotatef(angle, x, y, z);
|
||||
rotation.set(x, y, z).normalize();
|
||||
getMatrixStack().rotate((float)Math.toRadians(angle), rotation);
|
||||
}
|
||||
|
||||
public static void glRotated(double angle, double x, double y, double z) {
|
||||
GL11.glRotated(angle, x, y, z);
|
||||
rotation.set(x, y, z).normalize();
|
||||
getMatrixStack().rotate((float)Math.toRadians(angle), rotation);
|
||||
}
|
||||
|
||||
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();
|
||||
}
|
||||
}
|
||||
@@ -1,15 +1,29 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public class TessellatorManager {
|
||||
private static final ThreadLocal<Tessellator> theTessellator = ThreadLocal.withInitial(Tessellator::new);
|
||||
private static final ThreadLocal<CapturingTessellator> capturingTessellator = ThreadLocal.withInitial(CapturingTessellator::new);
|
||||
|
||||
private static final ThreadLocal<Boolean> currentlyCapturing = ThreadLocal.withInitial(() -> Boolean.FALSE);
|
||||
private static final Thread mainThread = Thread.currentThread();
|
||||
|
||||
public static Tessellator get() {
|
||||
if(isOnMainThread())
|
||||
if(currentlyCapturing.get()) {
|
||||
return capturingTessellator.get();
|
||||
} else if(isOnMainThread()) {
|
||||
return Tessellator.instance;
|
||||
return theTessellator.get();
|
||||
} else {
|
||||
// TODO: Verify this works correctly and nothing unexpected is grabbing a tessellator off the main thread
|
||||
// when not capturing
|
||||
throw new IllegalStateException("Tried to get the Tessellator off the main thread when not capturing!");
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean isOnMainThread() {
|
||||
@@ -17,10 +31,41 @@ public class TessellatorManager {
|
||||
}
|
||||
|
||||
public static boolean isMainInstance(Object instance) {
|
||||
return instance == Tessellator.instance;
|
||||
return instance == Tessellator.instance || isOnMainThread();
|
||||
}
|
||||
|
||||
public static void startCapturing() {
|
||||
if(currentlyCapturing.get()) throw new IllegalStateException("Tried to start capturing when already capturing!");
|
||||
currentlyCapturing.set(true);
|
||||
}
|
||||
|
||||
|
||||
public static List<Quad> stopCapturing() {
|
||||
if(!currentlyCapturing.get()) throw new IllegalStateException("Tried to stop capturing when not capturing!");
|
||||
currentlyCapturing.set(false);
|
||||
final CapturingTessellator tess = capturingTessellator.get();
|
||||
|
||||
// Be sure we got all the quads
|
||||
if(tess.isDrawing) tess.draw();
|
||||
|
||||
final List<Quad> quads = tess.getQuads();
|
||||
((ITessellatorInstance)tess).discard();
|
||||
|
||||
tess.clearQuads();
|
||||
return quads;
|
||||
}
|
||||
|
||||
static {
|
||||
System.out.println("[TessellatorManager] Initialized on thread " + mainThread.getName());
|
||||
}
|
||||
|
||||
public static void cleanup() {
|
||||
// Ensure we've cleaned everything up
|
||||
if(currentlyCapturing.get()) {
|
||||
currentlyCapturing.set(false);
|
||||
final CapturingTessellator tess = capturingTessellator.get();
|
||||
((ITessellatorInstance)tess).discard();
|
||||
tess.clearQuads();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,7 @@
|
||||
package com.gtnewhorizons.angelica.loading;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
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 +76,9 @@ public class MixinCompatHackTweaker implements ITweaker {
|
||||
if (FMLLaunchHandler.side().isClient()) {
|
||||
// Run after Mixins, but before LWJGl3ify
|
||||
Launch.classLoader.registerTransformer(RedirectorTransformer.class.getName());
|
||||
if(AngelicaConfig.enableSodium) {
|
||||
Launch.classLoader.registerTransformer(BlockTransformer.class.getName());
|
||||
}
|
||||
}
|
||||
|
||||
return new String[0];
|
||||
|
||||
@@ -25,8 +25,9 @@ public enum Mixins {
|
||||
|
||||
ANGELICA(new Builder("Angelica").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
|
||||
.setPhase(Phase.EARLY).addMixinClasses(
|
||||
"angelica.MixinEntityRenderer"
|
||||
|
||||
"angelica.MixinActiveRenderInfo"
|
||||
,"angelica.MixinEntityRenderer"
|
||||
,"angelica.vbo.MixinWavefrontObject"
|
||||
)
|
||||
),
|
||||
|
||||
@@ -42,6 +43,13 @@ public enum Mixins {
|
||||
"angelica.debug.MixinSplashProgress"
|
||||
)
|
||||
),
|
||||
|
||||
ANGELICA_THAUMCRAFT_COMPAT(new Builder("Angelica Thaumcraft Compat").addTargetedMod(TargetedMod.THAUMCRAFT).setSide(Side.CLIENT)
|
||||
.setPhase(Phase.EARLY).addMixinClasses(
|
||||
"angelica.thaumcraft.MixinClientTickEventsFML"
|
||||
)
|
||||
),
|
||||
|
||||
// Not compatible with the lwjgl debug callbacks, so disable if that's enabled
|
||||
ARCHAIC_SPLASH(new Builder("ArchaicFix Splash").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
|
||||
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.showSplashMemoryBar && !AngelicaMod.lwjglDebug).addMixinClasses(
|
||||
@@ -135,6 +143,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 +185,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")
|
||||
|
||||
+34
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
-3
@@ -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();
|
||||
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -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_]);
|
||||
}
|
||||
}
|
||||
+1
-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()) {
|
||||
|
||||
+1
-1
@@ -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;
|
||||
}
|
||||
|
||||
+3
-3
@@ -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;
|
||||
|
||||
+1
-1
@@ -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();
|
||||
|
||||
+2
-2
@@ -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();
|
||||
|
||||
+3
-3
@@ -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();
|
||||
}
|
||||
}
|
||||
+27
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.thaumcraft;
|
||||
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
import thaumcraft.client.lib.ClientTickEventsFML;
|
||||
|
||||
@Mixin(ClientTickEventsFML.class)
|
||||
public class MixinClientTickEventsFML {
|
||||
|
||||
/**
|
||||
* Thaumcraft disables lighting and only re-enables it if actually drawing an aspect(hovering over an item that
|
||||
* you can see the aspect for and draws it). This shoves in a lighting re-enable at the end so that it is always
|
||||
* re-enabled regardless.
|
||||
*/
|
||||
@Inject(method = "renderAspectsInGui", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glPopAttrib()V"), remap = false)
|
||||
private void angelica$lightingFix(CallbackInfo ci) {
|
||||
GL11.glEnable(GL11.GL_LIGHTING);
|
||||
}
|
||||
}
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.vbo;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IModelCustomExt;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraftforge.client.model.obj.GroupObject;
|
||||
import net.minecraftforge.client.model.obj.WavefrontObject;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.Unique;
|
||||
|
||||
@Mixin(value = WavefrontObject.class, remap = false)
|
||||
public abstract class MixinWavefrontObject implements IModelCustomExt {
|
||||
@Unique private VertexBuffer vertexBuffer;
|
||||
|
||||
@Shadow private GroupObject currentGroupObject;
|
||||
|
||||
@Shadow public abstract void tessellateAll(Tessellator tessellator);
|
||||
|
||||
@Unique VertexFormat format = DefaultVertexFormat.ITEM_VBO;
|
||||
|
||||
@Override
|
||||
public void rebuildVBO() {
|
||||
if(currentGroupObject == null) {
|
||||
throw new RuntimeException("No group object selected");
|
||||
}
|
||||
if (this.vertexBuffer != null) {
|
||||
this.vertexBuffer.close();
|
||||
}
|
||||
final Tessellator tessellator = Tessellator.instance;
|
||||
tessellator.startDrawing(currentGroupObject.glDrawingMode);
|
||||
tessellateAll(tessellator);
|
||||
|
||||
this.vertexBuffer = new VertexBuffer();
|
||||
this.vertexBuffer.bind();
|
||||
this.vertexBuffer.upload(tessellator, format);
|
||||
this.vertexBuffer.unbind();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderAllVBO() {
|
||||
if(vertexBuffer == null) {
|
||||
rebuildVBO();
|
||||
}
|
||||
vertexBuffer.bind();
|
||||
format.setupBufferState(0L);
|
||||
vertexBuffer.draw(GL11.GL_QUADS);
|
||||
format.clearBufferState();
|
||||
vertexBuffer.unbind();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.sodium;
|
||||
|
||||
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizons.angelica.glsm.TessellatorManager;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
@@ -85,6 +86,4 @@ public abstract class MixinTessellator implements ITessellatorInstance {
|
||||
return angelica$midTextureV;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
+2
-1
@@ -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,14 @@
|
||||
package com.gtnewhorizons.angelica.mixins.interfaces;
|
||||
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import net.minecraftforge.client.model.IModelCustom;
|
||||
|
||||
import static cpw.mods.fml.relauncher.Side.CLIENT;
|
||||
|
||||
public interface IModelCustomExt extends IModelCustom {
|
||||
@SideOnly(CLIENT)
|
||||
void rebuildVBO();
|
||||
|
||||
@SideOnly(CLIENT)
|
||||
void renderAllVBO();
|
||||
}
|
||||
+19
@@ -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;
|
||||
|
||||
@@ -11,7 +11,7 @@ public class AngelicaBlockSafetyRegistry {
|
||||
private static final StampedLock LOCK = new StampedLock();
|
||||
|
||||
public static boolean canBlockRenderOffThread(Block block) {
|
||||
long stamp = LOCK.readLock();
|
||||
final long stamp = LOCK.readLock();
|
||||
boolean isOffThread, shouldPopulate;
|
||||
try {
|
||||
isOffThread = SAFETY_MAP.getBoolean(block);
|
||||
@@ -32,9 +32,9 @@ public class AngelicaBlockSafetyRegistry {
|
||||
}
|
||||
|
||||
private static boolean populateCanRenderOffThread(Block block) {
|
||||
boolean canBeOffThread = !(block.getClass().getName().startsWith("gregtech."));
|
||||
final boolean canBeOffThread = !(block.getClass().getName().startsWith("gregtech."));
|
||||
|
||||
long stamp = LOCK.writeLock();
|
||||
final long stamp = LOCK.writeLock();
|
||||
|
||||
try {
|
||||
SAFETY_MAP.put(block, canBeOffThread);
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.transform;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import net.coderbot.iris.IrisLogging;
|
||||
import net.minecraft.launchwrapper.IClassTransformer;
|
||||
@@ -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) && AngelicaConfig.enableSodium) {
|
||||
Pair<String, String> fieldToRedirect = null;
|
||||
for(Pair<String, String> blockPairs : BlockBoundsFields) {
|
||||
if(fNode.name.equals(blockPairs.getLeft()) || fNode.name.equals(blockPairs.getRight())) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.gl.attribute;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
|
||||
public interface BufferVertexFormat {
|
||||
static BufferVertexFormat from(VertexFormat format) {
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.gl.attribute;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute;
|
||||
|
||||
import java.util.EnumMap;
|
||||
@@ -18,6 +19,12 @@ public class GlVertexFormat<T extends Enum<T>> implements BufferVertexFormat {
|
||||
private final EnumMap<T, GlVertexAttribute> attributesKeyed;
|
||||
private final GlVertexAttribute[] attributesArray;
|
||||
|
||||
/**
|
||||
* -- GETTER --
|
||||
*
|
||||
* The stride (or the size of) the vertex format in bytes
|
||||
*/
|
||||
@Getter
|
||||
private final int stride;
|
||||
|
||||
public GlVertexFormat(Class<T> attributeEnum, EnumMap<T, GlVertexAttribute> attributesKeyed, int stride) {
|
||||
@@ -36,7 +43,7 @@ public class GlVertexFormat<T extends Enum<T>> implements BufferVertexFormat {
|
||||
* @throws NullPointerException If the attribute does not exist in this format
|
||||
*/
|
||||
public GlVertexAttribute getAttribute(T name) {
|
||||
GlVertexAttribute attr = this.attributesKeyed.get(name);
|
||||
final GlVertexAttribute attr = this.attributesKeyed.get(name);
|
||||
|
||||
if (attr == null) {
|
||||
throw new NullPointerException("No attribute exists for " + name.toString());
|
||||
@@ -45,13 +52,6 @@ public class GlVertexFormat<T extends Enum<T>> implements BufferVertexFormat {
|
||||
return attr;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The stride (or the size of) the vertex format in bytes
|
||||
*/
|
||||
public int getStride() {
|
||||
return this.stride;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("GlVertexFormat<%s>{attributes=%d,stride=%d}", this.attributeEnum.getName(),
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -131,7 +131,7 @@ public class GLRenderDevice implements RenderDevice {
|
||||
|
||||
@Override
|
||||
public void deleteBuffer(GlBuffer buffer) {
|
||||
int handle = buffer.handle();
|
||||
final int handle = buffer.handle();
|
||||
buffer.invalidateHandle();
|
||||
|
||||
GL15.glDeleteBuffers(handle);
|
||||
@@ -139,7 +139,7 @@ public class GLRenderDevice implements RenderDevice {
|
||||
|
||||
@Override
|
||||
public void deleteVertexArray(GlVertexArray array) {
|
||||
int handle = array.handle();
|
||||
final int handle = array.handle();
|
||||
array.invalidateHandle();
|
||||
|
||||
GlFunctions.VERTEX_ARRAY.glDeleteVertexArrays(handle);
|
||||
@@ -176,7 +176,7 @@ public class GLRenderDevice implements RenderDevice {
|
||||
@Override
|
||||
public GlTessellation createTessellation(GlPrimitiveType primitiveType, TessellationBinding[] bindings) {
|
||||
if (GlVertexArrayTessellation.isSupported()) {
|
||||
GlVertexArrayTessellation tessellation = new GlVertexArrayTessellation(new GlVertexArray(GLRenderDevice.this), primitiveType, bindings);
|
||||
final GlVertexArrayTessellation tessellation = new GlVertexArrayTessellation(new GlVertexArray(GLRenderDevice.this), primitiveType, bindings);
|
||||
tessellation.init(this);
|
||||
|
||||
return tessellation;
|
||||
@@ -193,13 +193,13 @@ public class GLRenderDevice implements RenderDevice {
|
||||
|
||||
@Override
|
||||
public void multiDrawArrays(IntBuffer first, IntBuffer count) {
|
||||
GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType();
|
||||
final GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType();
|
||||
GL14.glMultiDrawArrays(primitiveType.getId(), first, count);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void multiDrawArraysIndirect(long pointer, int count, int stride) {
|
||||
GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType();
|
||||
final GlPrimitiveType primitiveType = GLRenderDevice.this.activeTessellation.getPrimitiveType();
|
||||
GlFunctions.INDIRECT_DRAW.glMultiDrawArraysIndirect(primitiveType.getId(), pointer, count, stride);
|
||||
}
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
+3
-7
@@ -1,11 +1,14 @@
|
||||
package me.jellysquid.mods.sodium.client.gl.tessellation;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding;
|
||||
import me.jellysquid.mods.sodium.client.gl.buffer.GlBuffer;
|
||||
|
||||
public class TessellationBinding {
|
||||
@Getter
|
||||
private final GlBuffer buffer;
|
||||
private final GlVertexAttributeBinding[] bindings;
|
||||
@Getter
|
||||
private final boolean instanced;
|
||||
|
||||
public TessellationBinding(GlBuffer buffer, GlVertexAttributeBinding[] bindings, boolean instanced) {
|
||||
@@ -14,15 +17,8 @@ public class TessellationBinding {
|
||||
this.instanced = instanced;
|
||||
}
|
||||
|
||||
public GlBuffer getBuffer() {
|
||||
return this.buffer;
|
||||
}
|
||||
|
||||
public GlVertexAttributeBinding[] getAttributeBindings() {
|
||||
return this.bindings;
|
||||
}
|
||||
|
||||
public boolean isInstanced() {
|
||||
return this.instanced;
|
||||
}
|
||||
}
|
||||
@@ -41,7 +41,7 @@ public class SodiumGameOptions {
|
||||
|
||||
public static class PerformanceSettings {
|
||||
public int chunkBuilderThreads = 0;
|
||||
public boolean alwaysDeferChunkUpdates = false;
|
||||
public boolean alwaysDeferChunkUpdates = true;
|
||||
public boolean useNoErrorGLContext = true;
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -22,10 +22,10 @@ public class VertexBufferBuilder implements VertexBufferView {
|
||||
|
||||
private void grow(int len) {
|
||||
// The new capacity will at least as large as the write it needs to service
|
||||
int cap = Math.max(this.capacity * 2, this.capacity + len);
|
||||
final int cap = Math.max(this.capacity * 2, this.capacity + len);
|
||||
|
||||
// Allocate a new buffer and copy the old buffer's contents into it
|
||||
ByteBuffer buffer = BufferUtils.createByteBuffer(cap);
|
||||
final ByteBuffer buffer = BufferUtils.createByteBuffer(cap);
|
||||
this.buffer.rewind();
|
||||
buffer.put(this.buffer);
|
||||
buffer.position(0);
|
||||
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
|
||||
import me.jellysquid.mods.sodium.client.util.math.Matrix4fExtended;
|
||||
import me.jellysquid.mods.sodium.client.util.math.MatrixUtil;
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer.GlyphVertexBufferWriterNio;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer.GlyphVertexBufferWriterUnsafe;
|
||||
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.line;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
|
||||
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
|
||||
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.line;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer.LineVertexBufferWriterNio;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer.LineVertexBufferWriterUnsafe;
|
||||
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.particle;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
|
||||
|
||||
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.particle;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer.ParticleVertexBufferWriterNio;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer.ParticleVertexBufferWriterUnsafe;
|
||||
|
||||
+2
-2
@@ -1,8 +1,8 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.quad;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
|
||||
import me.jellysquid.mods.sodium.client.util.math.Matrix4fExtended;
|
||||
import me.jellysquid.mods.sodium.client.util.math.MatrixUtil;
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.quad;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer.QuadVertexBufferWriterNio;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer.QuadVertexBufferWriterUnsafe;
|
||||
|
||||
+2
-2
@@ -14,9 +14,9 @@ public class QuadVertexBufferWriterNio extends VertexBufferWriterNio implements
|
||||
|
||||
@Override
|
||||
public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) {
|
||||
int i = this.writeOffset;
|
||||
final int i = this.writeOffset;
|
||||
|
||||
ByteBuffer buf = this.byteBuffer;
|
||||
final ByteBuffer buf = this.byteBuffer;
|
||||
buf.putFloat(i, x);
|
||||
buf.putFloat(i + 4, y);
|
||||
buf.putFloat(i + 8, z);
|
||||
|
||||
+1
-1
@@ -13,7 +13,7 @@ public class QuadVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe imple
|
||||
|
||||
@Override
|
||||
public void writeQuad(float x, float y, float z, int color, float u, float v, int light, int overlay, int normal) {
|
||||
long i = this.writePointer;
|
||||
final long i = this.writePointer;
|
||||
|
||||
CompatMemoryUtil.memPutFloat(i, x);
|
||||
CompatMemoryUtil.memPutFloat(i + 4, y);
|
||||
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
|
||||
import me.jellysquid.mods.sodium.client.util.math.Matrix4fExtended;
|
||||
import me.jellysquid.mods.sodium.client.util.math.MatrixUtil;
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer.BasicScreenQuadVertexBufferWriterNio;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer.BasicScreenQuadVertexBufferWriterUnsafe;
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.type;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
|
||||
|
||||
|
||||
+36
-37
@@ -3,6 +3,7 @@ package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArrayFIFOQueue;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
||||
import lombok.Setter;
|
||||
import me.jellysquid.mods.sodium.client.gl.arena.GlBufferArena;
|
||||
import me.jellysquid.mods.sodium.client.gl.arena.GlBufferSegment;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttribute;
|
||||
@@ -123,20 +124,20 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
commandList.bindBuffer(GlBufferTarget.ARRAY_BUFFER, this.uploadBuffer);
|
||||
|
||||
while (!this.pendingUploads.isEmpty()) {
|
||||
ChunkRegion<MultidrawGraphicsState> region = this.pendingUploads.dequeue();
|
||||
final ChunkRegion<MultidrawGraphicsState> region = this.pendingUploads.dequeue();
|
||||
|
||||
GlBufferArena arena = region.getBufferArena();
|
||||
GlBuffer buffer = arena.getBuffer();
|
||||
final GlBufferArena arena = region.getBufferArena();
|
||||
final GlBuffer buffer = arena.getBuffer();
|
||||
|
||||
ObjectArrayList<ChunkBuildResult<MultidrawGraphicsState>> uploadQueue = region.getUploadQueue();
|
||||
final ObjectArrayList<ChunkBuildResult<MultidrawGraphicsState>> uploadQueue = region.getUploadQueue();
|
||||
arena.prepareBuffer(commandList, getUploadQueuePayloadSize(uploadQueue));
|
||||
|
||||
for (ChunkBuildResult<MultidrawGraphicsState> result : uploadQueue) {
|
||||
ChunkRenderContainer<MultidrawGraphicsState> render = result.render;
|
||||
ChunkRenderData data = result.data;
|
||||
final ChunkRenderContainer<MultidrawGraphicsState> render = result.render;
|
||||
final ChunkRenderData data = result.data;
|
||||
|
||||
for (BlockRenderPass pass : result.passesToUpload) {
|
||||
MultidrawGraphicsState graphics = render.getGraphicsState(pass);
|
||||
final MultidrawGraphicsState graphics = render.getGraphicsState(pass);
|
||||
|
||||
// De-allocate the existing buffer arena for this render
|
||||
// This will allow it to be cheaply re-allocated just below
|
||||
@@ -144,16 +145,16 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
graphics.delete(commandList);
|
||||
}
|
||||
|
||||
ChunkMeshData meshData = data.getMesh(pass);
|
||||
final ChunkMeshData meshData = data.getMesh(pass);
|
||||
|
||||
if (meshData.hasVertexData()) {
|
||||
VertexData upload = meshData.takeVertexData();
|
||||
final VertexData upload = meshData.takeVertexData();
|
||||
|
||||
commandList.uploadData(this.uploadBuffer, upload.buffer);
|
||||
|
||||
GlBufferSegment segment = arena.uploadBuffer(commandList, this.uploadBuffer, 0, upload.buffer.capacity());
|
||||
final GlBufferSegment segment = arena.uploadBuffer(commandList, this.uploadBuffer, 0, upload.buffer.capacity());
|
||||
|
||||
MultidrawGraphicsState graphicsState = new MultidrawGraphicsState(render, region, segment, meshData, this.vertexFormat);
|
||||
final MultidrawGraphicsState graphicsState = new MultidrawGraphicsState(render, region, segment, meshData, this.vertexFormat);
|
||||
if(pass.isTranslucent()) {
|
||||
upload.buffer.limit(upload.buffer.capacity());
|
||||
upload.buffer.position(0);
|
||||
@@ -217,16 +218,14 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* -- SETTER --
|
||||
* Sets whether to reverse the order in which regions are drawn
|
||||
*/
|
||||
@Setter
|
||||
private boolean reverseRegions = false;
|
||||
private ChunkCameraContext regionCamera;
|
||||
|
||||
/**
|
||||
* Sets whether to reverse the order in which regions are drawn (fixes
|
||||
*/
|
||||
public void setReverseRegions(boolean flag) {
|
||||
this.reverseRegions = flag;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render(CommandList commandList, ChunkRenderListIterator<MultidrawGraphicsState> renders, ChunkCameraContext camera) {
|
||||
this.bufferManager.cleanup();
|
||||
@@ -242,7 +241,7 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
long pointer = this.commandBuffer == null ? this.commandClientBufferBuilder.getBufferAddress() : 0L;
|
||||
|
||||
for (ChunkRegion<?> region : this.pendingBatches) {
|
||||
ChunkDrawCallBatcher batch = region.getDrawBatcher();
|
||||
final ChunkDrawCallBatcher batch = region.getDrawBatcher();
|
||||
|
||||
if (!batch.isEmpty()) {
|
||||
try (DrawCommandList drawCommandList = commandList.beginTessellating(region.getTessellation())) {
|
||||
@@ -262,11 +261,11 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
this.commandClientBufferBuilder.begin();
|
||||
|
||||
if(this.reverseRegions) {
|
||||
ChunkCameraContext camera = this.regionCamera;
|
||||
final ChunkCameraContext camera = this.regionCamera;
|
||||
for (ChunkRegion<?> region : this.pendingBatches) {
|
||||
float x = camera.getChunkModelOffset(region.getCenterBlockX(), camera.blockOriginX, camera.originX);
|
||||
float y = camera.getChunkModelOffset(region.getCenterBlockY(), camera.blockOriginY, camera.originY);
|
||||
float z = camera.getChunkModelOffset(region.getCenterBlockZ(), camera.blockOriginZ, camera.originZ);
|
||||
final float x = camera.getChunkModelOffset(region.getCenterBlockX(), camera.blockOriginX, camera.originX);
|
||||
final float y = camera.getChunkModelOffset(region.getCenterBlockY(), camera.blockOriginY, camera.originY);
|
||||
final float z = camera.getChunkModelOffset(region.getCenterBlockZ(), camera.blockOriginZ, camera.originZ);
|
||||
region.camDistance = x * x + y * y + z * z;
|
||||
}
|
||||
|
||||
@@ -274,7 +273,7 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
}
|
||||
|
||||
for (ChunkRegion<?> region : this.pendingBatches) {
|
||||
ChunkDrawCallBatcher batcher = region.getDrawBatcher();
|
||||
final ChunkDrawCallBatcher batcher = region.getDrawBatcher();
|
||||
batcher.end();
|
||||
|
||||
this.commandClientBufferBuilder.pushCommandBuffer(batcher);
|
||||
@@ -285,13 +284,13 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
|
||||
private void setupUploadBatches(Iterator<ChunkBuildResult<MultidrawGraphicsState>> renders) {
|
||||
while (renders.hasNext()) {
|
||||
ChunkBuildResult<MultidrawGraphicsState> result = renders.next();
|
||||
final ChunkBuildResult<MultidrawGraphicsState> result = renders.next();
|
||||
|
||||
if(result == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
ChunkRenderContainer<MultidrawGraphicsState> render = result.render;
|
||||
final ChunkRenderContainer<MultidrawGraphicsState> render = result.render;
|
||||
|
||||
ChunkRegion<MultidrawGraphicsState> region = this.bufferManager.getRegion(render.getChunkX(), render.getChunkY(), render.getChunkZ());
|
||||
|
||||
@@ -304,7 +303,7 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
region = this.bufferManager.getOrCreateRegion(render.getChunkX(), render.getChunkY(), render.getChunkZ());
|
||||
}
|
||||
|
||||
ObjectArrayList<ChunkBuildResult<MultidrawGraphicsState>> uploadQueue = region.getUploadQueue();
|
||||
final ObjectArrayList<ChunkBuildResult<MultidrawGraphicsState>> uploadQueue = region.getUploadQueue();
|
||||
|
||||
if (uploadQueue.isEmpty()) {
|
||||
this.pendingUploads.enqueue(region);
|
||||
@@ -321,18 +320,18 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
int drawCount = 0;
|
||||
|
||||
while (it.hasNext()) {
|
||||
MultidrawGraphicsState state = it.getGraphicsState();
|
||||
int visible = it.getVisibleFaces();
|
||||
final MultidrawGraphicsState state = it.getGraphicsState();
|
||||
final int visible = it.getVisibleFaces();
|
||||
|
||||
int index = drawCount++;
|
||||
float x = camera.getChunkModelOffset(state.getX(), camera.blockOriginX, camera.originX);
|
||||
float y = camera.getChunkModelOffset(state.getY(), camera.blockOriginY, camera.originY);
|
||||
float z = camera.getChunkModelOffset(state.getZ(), camera.blockOriginZ, camera.originZ);
|
||||
final int index = drawCount++;
|
||||
final float x = camera.getChunkModelOffset(state.getX(), camera.blockOriginX, camera.originX);
|
||||
final float y = camera.getChunkModelOffset(state.getY(), camera.blockOriginY, camera.originY);
|
||||
final float z = camera.getChunkModelOffset(state.getZ(), camera.blockOriginZ, camera.originZ);
|
||||
|
||||
this.uniformBufferBuilder.pushChunkDrawParams(x, y, z);
|
||||
|
||||
ChunkRegion<MultidrawGraphicsState> region = state.getRegion();
|
||||
ChunkDrawCallBatcher batch = region.getDrawBatcher();
|
||||
final ChunkRegion<MultidrawGraphicsState> region = state.getRegion();
|
||||
final ChunkDrawCallBatcher batch = region.getDrawBatcher();
|
||||
|
||||
if (!batch.isBuilding()) {
|
||||
batch.begin();
|
||||
@@ -440,7 +439,7 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
return false;
|
||||
}
|
||||
|
||||
Matcher matcher = INTEL_BUILD_MATCHER.matcher(version);
|
||||
final Matcher matcher = INTEL_BUILD_MATCHER.matcher(version);
|
||||
|
||||
// If the version pattern doesn't match, assume we're dealing with something special
|
||||
if (!matcher.matches()) {
|
||||
@@ -459,7 +458,7 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
|
||||
@Override
|
||||
public List<String> getDebugStrings() {
|
||||
List<String> list = new ArrayList<>();
|
||||
final List<String> list = new ArrayList<>();
|
||||
list.add(String.format("Active Buffers: %s", this.bufferManager.getAllocatedRegionCount()));
|
||||
list.add(String.format("Submission Mode: %s", this.commandBuffer != null ? EnumChatFormatting.AQUA + "Buffer" : EnumChatFormatting.LIGHT_PURPLE + "Client Memory"));
|
||||
|
||||
|
||||
+1
-1
@@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+2
-2
@@ -27,9 +27,9 @@ public class HFPModelVertexBufferWriterNio extends VertexBufferWriterNio impleme
|
||||
}
|
||||
|
||||
private void writeQuadInternal(short x, short y, short z, int color, short u, short v, int light) {
|
||||
int i = this.writeOffset;
|
||||
final int i = this.writeOffset;
|
||||
|
||||
ByteBuffer buffer = this.byteBuffer;
|
||||
final ByteBuffer buffer = this.byteBuffer;
|
||||
buffer.putShort(i, x);
|
||||
buffer.putShort(i + 2, y);
|
||||
buffer.putShort(i + 4, z);
|
||||
|
||||
+2
-9
@@ -8,27 +8,20 @@ import me.jellysquid.mods.sodium.client.model.vertex.type.BlittableVertexType;
|
||||
import me.jellysquid.mods.sodium.client.model.vertex.type.ChunkVertexType;
|
||||
import me.jellysquid.mods.sodium.client.render.chunk.format.ChunkMeshAttribute;
|
||||
import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink;
|
||||
import net.coderbot.iris.sodium.vertex_format.IrisGlVertexAttributeFormat;
|
||||
|
||||
/**
|
||||
* Uses half-precision floating point numbers to represent position coordinates and normalized unsigned shorts for
|
||||
* texture coordinates. All texel positions in the block diffuse texture atlas can be exactly mapped (including
|
||||
* their centering offset), as the
|
||||
* their centering offset).
|
||||
*/
|
||||
public class HFPModelVertexType implements ChunkVertexType {
|
||||
// TODO Iris?
|
||||
public static final int STRIDE = 44; // 20
|
||||
public static final int STRIDE = 20;
|
||||
public static final GlVertexFormat<ChunkMeshAttribute> VERTEX_FORMAT =
|
||||
GlVertexFormat.builder(ChunkMeshAttribute.class, STRIDE)
|
||||
.addElement(ChunkMeshAttribute.POSITION, 0, GlVertexAttributeFormat.UNSIGNED_SHORT, 3, false)
|
||||
.addElement(ChunkMeshAttribute.COLOR, 8, GlVertexAttributeFormat.UNSIGNED_BYTE, 4, true)
|
||||
.addElement(ChunkMeshAttribute.TEXTURE, 12, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, false)
|
||||
.addElement(ChunkMeshAttribute.LIGHT, 16, GlVertexAttributeFormat.UNSIGNED_SHORT, 2, true)
|
||||
.addElement(ChunkMeshAttribute.MID_TEX_COORD, 20, GlVertexAttributeFormat.FLOAT, 2, false)
|
||||
.addElement(ChunkMeshAttribute.TANGENT, 28, IrisGlVertexAttributeFormat.BYTE, 4, true)
|
||||
.addElement(ChunkMeshAttribute.NORMAL, 32, IrisGlVertexAttributeFormat.BYTE, 3, true)
|
||||
.addElement(ChunkMeshAttribute.BLOCK_ID, 36, IrisGlVertexAttributeFormat.SHORT, 2, false)
|
||||
.addElement(ChunkMeshAttribute.MID_BLOCK, 40, IrisGlVertexAttributeFormat.BYTE, 3, false)
|
||||
.build();
|
||||
|
||||
|
||||
|
||||
+26
-30
@@ -3,7 +3,6 @@ package me.jellysquid.mods.sodium.client.render.chunk.tasks;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionDataBuilder;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.TessellatorManager;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
@@ -20,12 +19,10 @@ import me.jellysquid.mods.sodium.client.util.MathUtil;
|
||||
import me.jellysquid.mods.sodium.client.util.task.CancellationSource;
|
||||
import me.jellysquid.mods.sodium.client.world.WorldSlice;
|
||||
import me.jellysquid.mods.sodium.client.world.cloned.ChunkRenderContext;
|
||||
import me.jellysquid.mods.sodium.common.config.SodiumConfig;
|
||||
import net.coderbot.iris.vertices.ExtendedDataHelper;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.client.renderer.RenderBlocks;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
|
||||
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
@@ -88,16 +85,16 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
}
|
||||
|
||||
private boolean rendersOffThread(Block block) {
|
||||
int type = block.getRenderType();
|
||||
final int type = block.getRenderType();
|
||||
return type < 42 && type != 22 && AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource) {
|
||||
// COMPATIBLITY NOTE: Oculus relies on the LVT of this method being unchanged, at least in 16.5
|
||||
ChunkRenderData.Builder renderData = new ChunkRenderData.Builder();
|
||||
ChunkOcclusionDataBuilder occluder = new ChunkOcclusionDataBuilder();
|
||||
ChunkRenderBounds.Builder bounds = new ChunkRenderBounds.Builder();
|
||||
final ChunkRenderData.Builder renderData = new ChunkRenderData.Builder();
|
||||
final ChunkOcclusionDataBuilder occluder = new ChunkOcclusionDataBuilder();
|
||||
final ChunkRenderBounds.Builder bounds = new ChunkRenderBounds.Builder();
|
||||
|
||||
buffers.init(renderData);
|
||||
|
||||
@@ -106,13 +103,12 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
final WorldSlice slice = cache.getWorldSlice();
|
||||
final RenderBlocks renderBlocks = new RenderBlocks(slice);
|
||||
|
||||
int baseX = this.render.getOriginX();
|
||||
int baseY = this.render.getOriginY();
|
||||
int baseZ = this.render.getOriginZ();
|
||||
final int baseX = this.render.getOriginX();
|
||||
final int baseY = this.render.getOriginY();
|
||||
final int baseZ = this.render.getOriginZ();
|
||||
|
||||
BlockPos.Mutable pos = new BlockPos.Mutable();
|
||||
BlockPos renderOffset = this.offset;
|
||||
final Tessellator tessellator = TessellatorManager.get();
|
||||
final BlockPos.Mutable pos = new BlockPos.Mutable();
|
||||
final BlockPos renderOffset = this.offset;
|
||||
|
||||
boolean hasMainThreadBlocks = false;
|
||||
|
||||
@@ -123,7 +119,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
|
||||
for (int relZ = 0; relZ < 16; relZ++) {
|
||||
for (int relX = 0; relX < 16; relX++) {
|
||||
Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
|
||||
final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
|
||||
|
||||
// If the block is vanilla air, assume it renders nothing. Don't use isAir because mods
|
||||
// can abuse it for all sorts of things
|
||||
@@ -131,7 +127,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
continue;
|
||||
}
|
||||
|
||||
int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
|
||||
final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
|
||||
|
||||
pos.set(baseX + relX, baseY + relY, baseZ + relZ);
|
||||
buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ());
|
||||
@@ -142,10 +138,10 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
// Do regular block rendering
|
||||
for (BlockRenderPass pass : BlockRenderPass.VALUES) {
|
||||
if (block.canRenderInPass(pass.ordinal()) && (!AngelicaConfig.enableSodiumFluidRendering || !(block instanceof IFluidBlock))) {
|
||||
long seed = MathUtil.hashPos(pos.x, pos.y, pos.z);
|
||||
final 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, renderBlocks, block, meta, pos, buffers.get(pass), true, seed)) {
|
||||
if (cache.getBlockRenderer().renderModel(cache.getWorldSlice(), renderBlocks, block, meta, pos, buffers.get(pass), true, seed)) {
|
||||
bounds.addBlock(relX, relY, relZ);
|
||||
}
|
||||
}
|
||||
@@ -170,7 +166,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
if(AngelicaConfig.enableIris) buffers.iris$resetBlockContext();
|
||||
|
||||
if (block.hasTileEntity(meta)) {
|
||||
TileEntity entity = slice.getTileEntity(pos.x, pos.y, pos.z);
|
||||
final TileEntity entity = slice.getTileEntity(pos.x, pos.y, pos.z);
|
||||
|
||||
final TileEntitySpecialRenderer renderer = TileEntityRendererDispatcher.instance.getSpecialRenderer(entity);
|
||||
if (entity != null && renderer != null) {
|
||||
@@ -202,7 +198,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
|
||||
render.setRebuildForTranslucents(false);
|
||||
for (BlockRenderPass pass : BlockRenderPass.VALUES) {
|
||||
ChunkMeshData mesh = buffers.createMesh(pass, (float)camera.x - offset.getX(), (float)camera.y - offset.getY(), (float)camera.z - offset.getZ(), this.translucencySorting);
|
||||
final ChunkMeshData mesh = buffers.createMesh(pass, (float)camera.x - offset.getX(), (float)camera.y - offset.getY(), (float)camera.z - offset.getZ(), this.translucencySorting);
|
||||
|
||||
if (mesh != null) {
|
||||
renderData.setMesh(pass, mesh);
|
||||
@@ -223,20 +219,20 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
* TODO: Deduplicate this with the main method above.
|
||||
*/
|
||||
private void performMainBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource, ChunkRenderBounds.Builder bounds) {
|
||||
WorldSlice slice = cache.getWorldSlice();
|
||||
BlockPos.Mutable pos = new BlockPos.Mutable();
|
||||
int baseX = this.render.getOriginX();
|
||||
int baseY = this.render.getOriginY();
|
||||
int baseZ = this.render.getOriginZ();
|
||||
BlockPos renderOffset = this.offset;
|
||||
RenderBlocks rb = new RenderBlocks(slice);
|
||||
final WorldSlice slice = cache.getWorldSlice();
|
||||
final BlockPos.Mutable pos = new BlockPos.Mutable();
|
||||
final int baseX = this.render.getOriginX();
|
||||
final int baseY = this.render.getOriginY();
|
||||
final int baseZ = this.render.getOriginZ();
|
||||
final BlockPos renderOffset = this.offset;
|
||||
final RenderBlocks rb = new RenderBlocks(slice.getWorld());
|
||||
for (int relY = 0; relY < 16; relY++) {
|
||||
if (cancellationSource.isCancelled()) {
|
||||
return;
|
||||
}
|
||||
for (int relZ = 0; relZ < 16; relZ++) {
|
||||
for (int relX = 0; relX < 16; relX++) {
|
||||
Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
|
||||
final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
|
||||
|
||||
// Only render blocks that need main thread assistance
|
||||
if (block.getMaterial() == Material.air || rendersOffThread(block)) {
|
||||
@@ -246,7 +242,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
// TODO: Collect data on which render types are hitting this code path most often
|
||||
// so mods can be updated slowly
|
||||
|
||||
int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
|
||||
final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
|
||||
|
||||
pos.set(baseX + relX, baseY + relY, baseZ + relZ);
|
||||
buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ());
|
||||
@@ -255,10 +251,10 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
// Do regular block rendering
|
||||
for (BlockRenderPass pass : BlockRenderPass.VALUES) {
|
||||
if (block.canRenderInPass(pass.ordinal()) && (!AngelicaConfig.enableSodiumFluidRendering || !(block instanceof IFluidBlock))) {
|
||||
long seed = MathUtil.hashPos(pos.x, pos.y, pos.z);
|
||||
final 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(), rb, block, meta, pos, buffers.get(pass), true, seed)) {
|
||||
bounds.addBlock(relX, relY, relZ);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
package me.jellysquid.mods.sodium.client.render.pipeline;
|
||||
|
||||
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.compat.nd.RecyclingList;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
|
||||
import com.gtnewhorizons.angelica.glsm.TessellatorManager;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightMode;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider;
|
||||
@@ -21,12 +21,9 @@ import net.coderbot.iris.block_rendering.BlockRenderingSettings;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.RenderBlocks;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import org.joml.Vector3d;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
@@ -52,7 +49,7 @@ public class BlockRenderer {
|
||||
this.useAmbientOcclusion = Minecraft.getMinecraft().gameSettings.ambientOcclusion > 0;
|
||||
}
|
||||
|
||||
public boolean renderModel(IBlockAccess world, Tessellator tessellator, RenderBlocks renderBlocks, Block block, int meta, BlockPos pos, ChunkModelBuffers buffers, boolean cull, long seed) {
|
||||
public boolean renderModel(IBlockAccess world, RenderBlocks renderBlocks, Block block, int meta, BlockPos pos, ChunkModelBuffers buffers, boolean cull, long seed) {
|
||||
final LightMode mode = this.getLightingMode(block);
|
||||
final LightPipeline lighter = this.lighters.getLighter(mode);
|
||||
|
||||
@@ -61,85 +58,29 @@ public class BlockRenderer {
|
||||
boolean rendered = false;
|
||||
|
||||
try {
|
||||
tessellator.startDrawingQuads();
|
||||
TessellatorManager.startCapturing();
|
||||
final CapturingTessellator tess = (CapturingTessellator) TessellatorManager.get();
|
||||
tess.startDrawingQuads();
|
||||
// RenderBlocks adds the subchunk-relative coordinates as the offset, cancel it out here
|
||||
tess.setOffset(pos);
|
||||
|
||||
renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z);
|
||||
|
||||
|
||||
final List<Quad> all = tessellatorToQuadList(tessellator, pos);
|
||||
final List<Quad> quads = TessellatorManager.stopCapturing();
|
||||
|
||||
for (ModelQuadFacing facing : ModelQuadFacing.VALUES) {
|
||||
this.random.setSeed(seed);
|
||||
this.renderQuadList(pos, lighter, buffers, all, facing);
|
||||
this.renderQuadList(pos, lighter, buffers, quads, facing);
|
||||
}
|
||||
|
||||
if (!all.isEmpty()) rendered = true;
|
||||
if (!quads.isEmpty()) rendered = true;
|
||||
} finally {
|
||||
((ITessellatorInstance) tessellator).discard();
|
||||
TessellatorManager.cleanup();
|
||||
}
|
||||
|
||||
|
||||
return rendered;
|
||||
}
|
||||
|
||||
private int tesselatorDataCount;
|
||||
private List<Quad> tessellatorToQuadList(Tessellator t, BlockPos pos) {
|
||||
// Adapted from Neodymium
|
||||
tesselatorDataCount++;
|
||||
|
||||
// List<String> errors = new ArrayList<>();
|
||||
// List<String> warnings = new ArrayList<>();
|
||||
// if(t.drawMode != GL11.GL_QUADS && t.drawMode != GL11.GL_TRIANGLES) {
|
||||
// errors.add("Unsupported draw mode: " + t.drawMode);
|
||||
// }
|
||||
// if(!t.hasTexture) {
|
||||
// errors.add("Texture data is missing.");
|
||||
// }
|
||||
// if(!t.hasBrightness) {
|
||||
// warnings.add("Brightness data is missing");
|
||||
// }
|
||||
// if(!t.hasColor) {
|
||||
// warnings.add("Color data is missing");
|
||||
// }
|
||||
// if(t.hasNormals && GL11.glIsEnabled(GL11.GL_LIGHTING)) {
|
||||
// errors.add("Chunk uses GL lighting, this is not implemented.");
|
||||
// }
|
||||
FLAGS.hasBrightness = t.hasBrightness;
|
||||
FLAGS.hasColor = t.hasColor;
|
||||
|
||||
int verticesPerPrimitive = t.drawMode == GL11.GL_QUADS ? 4 : 3;
|
||||
|
||||
for(int quadI = 0; quadI < t.vertexCount / verticesPerPrimitive; quadI++) {
|
||||
final Quad quad = quadBuf.next();
|
||||
// RenderBlocks adds the subchunk-relative coordinates as the offset, cancel it out here
|
||||
quad.setState(t.rawBuffer, quadI * (verticesPerPrimitive * 8), FLAGS, t.drawMode, -pos.x, -pos.y, -pos.z);
|
||||
|
||||
if(quad.deleted) {
|
||||
quadBuf.remove();
|
||||
}
|
||||
}
|
||||
// final boolean silenceErrors = false;
|
||||
//
|
||||
// if(!quadBuf.isEmpty() && (!errors.isEmpty() || !warnings.isEmpty()) && /*!Config.silenceErrors*/!silenceErrors) {
|
||||
// for(String error : errors) {
|
||||
// LOGGER.error("Error: " + error);
|
||||
// }
|
||||
// for(String warning : warnings) {
|
||||
// LOGGER.error("Warning: " + warning);
|
||||
// }
|
||||
// LOGGER.error("(Tessellator pos: ({}, {}, {}), Tessellation count: {}", t.xOffset, t.yOffset, t.zOffset, tesselatorDataCount);
|
||||
// LOGGER.error("Stack trace:");
|
||||
// try {
|
||||
// // Generate a stack trace
|
||||
// throw new IllegalArgumentException();
|
||||
// } catch(IllegalArgumentException e) {
|
||||
// e.printStackTrace();
|
||||
// }
|
||||
// }
|
||||
final List<Quad> quads = quadBuf.getAsList();
|
||||
quadBuf.reset();
|
||||
return quads;
|
||||
}
|
||||
|
||||
private void renderQuadList(BlockPos pos, LightPipeline lighter, ChunkModelBuffers buffers, List<Quad> quads, ModelQuadFacing facing) {
|
||||
|
||||
final ModelVertexSink sink = buffers.getSink(facing);
|
||||
@@ -191,7 +132,7 @@ public class BlockRenderer {
|
||||
final float u = quad.getTexU(srcIndex);
|
||||
final float v = quad.getTexV(srcIndex);
|
||||
|
||||
int quadLight = quad.getLight(srcIndex);
|
||||
final int quadLight = quad.getLight(srcIndex);
|
||||
final int lm = useSeparateAo ? ModelQuadUtil.mergeBakedLight(quadLight, light.lm[srcIndex]) : quadLight;
|
||||
|
||||
sink.writeQuad(x, y, z, color, u, v, lm);
|
||||
@@ -214,7 +155,7 @@ public class BlockRenderer {
|
||||
boolean hasTexture;
|
||||
public boolean hasBrightness;
|
||||
public boolean hasColor;
|
||||
boolean hasNormals;
|
||||
public boolean hasNormals;
|
||||
|
||||
public Flags(byte flags) {
|
||||
hasTexture = (flags & 1) != 0;
|
||||
|
||||
Loaded 100 of 119 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user