mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-21 21:02:15 +00:00
Compare commits
8
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
388929cc0c | ||
|
|
6691511e17 | ||
|
|
b956a44857 | ||
|
|
8863826d0e | ||
|
|
65d9bf8f2f | ||
|
|
3ee82e7157 | ||
|
|
3b61bb74a2 | ||
|
|
f378b6e7ba |
No files matched your search
@@ -84,7 +84,6 @@ dependencies {
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds:1.5.3:dev") // Mixin Version
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds-Legacy:1.4.7:dev") // ASM Version
|
||||
|
||||
compileOnly("com.github.GTNewHorizons:Jabba:1.3.1:dev")
|
||||
compileOnly(rfg.deobf("curse.maven:campfirebackport-387444:4611675"))
|
||||
// HMMMMM
|
||||
compileOnly(rfg.deobf("curse.maven:journeymap-32274:2367915"))
|
||||
|
||||
@@ -11,6 +11,7 @@ import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
@@ -246,6 +247,10 @@ public class BatchingFontRenderer {
|
||||
// Sort&Draw
|
||||
batchCommands.sort(FontDrawCmd.DRAW_ORDER_COMPARATOR);
|
||||
|
||||
final boolean isTextureEnabledBefore = GLStateManager.glIsEnabled(GL11.GL_TEXTURE_2D);
|
||||
final int boundTextureBefore = GLStateManager.getBoundTexture();
|
||||
boolean textureChanged = false;
|
||||
|
||||
ResourceLocation lastTexture = DUMMY_RESOURCE_LOCATION;
|
||||
GLStateManager.enableTexture();
|
||||
GLStateManager.enableAlphaTest();
|
||||
@@ -274,7 +279,8 @@ public class BatchingFontRenderer {
|
||||
GLStateManager.disableTexture();
|
||||
}
|
||||
if (cmd.texture != null) {
|
||||
((FontRendererAccessor) (Object) underlying).angelica$bindTexture(cmd.texture);
|
||||
((FontRendererAccessor) underlying).angelica$bindTexture(cmd.texture);
|
||||
textureChanged = true;
|
||||
}
|
||||
lastTexture = cmd.texture;
|
||||
}
|
||||
@@ -285,6 +291,13 @@ public class BatchingFontRenderer {
|
||||
|
||||
glPopClientAttrib();
|
||||
|
||||
if (isTextureEnabledBefore) {
|
||||
GLStateManager.enableTexture();
|
||||
}
|
||||
if (textureChanged) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, boundTextureBefore);
|
||||
}
|
||||
|
||||
// Clear for the next batch
|
||||
batchCommandPool.addAll(batchCommands);
|
||||
batchCommands.clear();
|
||||
|
||||
@@ -9,6 +9,7 @@ import cpw.mods.fml.relauncher.ReflectionHelper;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
||||
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import org.joml.Vector3d;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
@@ -44,6 +45,9 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
|
||||
// Any offset we need to the Tesselator's offset!
|
||||
private final BlockPos offset = new BlockPos();
|
||||
|
||||
private final Vector3d storedTranslation = new Vector3d();
|
||||
private boolean translationStored = false;
|
||||
|
||||
public void setOffset(BlockPos pos) {
|
||||
this.offset.set(pos);
|
||||
}
|
||||
@@ -53,7 +57,7 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
|
||||
|
||||
|
||||
static {
|
||||
Field rbs = ReflectionHelper.findField(Tessellator.class, "rawBufferSize");
|
||||
final Field rbs = ReflectionHelper.findField(Tessellator.class, "rawBufferSize");
|
||||
rbs.setAccessible(true);
|
||||
try {
|
||||
sRawBufferSize = MethodHandles.lookup().unreflectSetter(rbs);
|
||||
@@ -137,6 +141,22 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
|
||||
return byteBuffer;
|
||||
}
|
||||
|
||||
public void storeTranslation() {
|
||||
if(translationStored) throw new IllegalStateException("Translation already stored!");
|
||||
translationStored = true;
|
||||
this.storedTranslation.set(xOffset, yOffset, zOffset);
|
||||
}
|
||||
|
||||
public void restoreTranslation() {
|
||||
if(!translationStored) throw new IllegalStateException("Translation not stored!");
|
||||
|
||||
xOffset = storedTranslation.x;
|
||||
yOffset = storedTranslation.y;
|
||||
zOffset = storedTranslation.z;
|
||||
storedTranslation.zero();
|
||||
translationStored = false;
|
||||
}
|
||||
|
||||
public static int createBrightness(int sky, int block) {
|
||||
return sky << 20 | block << 4;
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ public class VertexBuffer implements AutoCloseable {
|
||||
|
||||
public VertexBuffer upload(ByteBuffer buffer) {
|
||||
if(format == null) throw new IllegalStateException("No format specified for VBO upload");
|
||||
upload(buffer, buffer.capacity() / format.getVertexSize());
|
||||
upload(buffer, buffer.remaining() / format.getVertexSize());
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -75,11 +75,8 @@ public class VertexBuffer implements AutoCloseable {
|
||||
unbind();
|
||||
}
|
||||
public void render() {
|
||||
if(format == null) throw new IllegalStateException("No format specified for VBO render");
|
||||
bind();
|
||||
format.setupBufferState(0L);
|
||||
setupState();
|
||||
draw();
|
||||
format.clearBufferState();
|
||||
unbind();
|
||||
cleanupState();
|
||||
}
|
||||
}
|
||||
@@ -50,8 +50,9 @@ public class VertexFormat {
|
||||
|
||||
final int i = this.getVertexSize();
|
||||
final List<VertexFormatElement> list = this.getElements();
|
||||
final int listSize = list.size();
|
||||
|
||||
for(int j = 0; j < list.size(); ++j) {
|
||||
for(int j = 0; j < listSize; ++j) {
|
||||
list.get(j).setupBufferState(l + this.offsets.getInt(j), i);
|
||||
}
|
||||
}
|
||||
@@ -66,8 +67,11 @@ public class VertexFormat {
|
||||
return;
|
||||
}
|
||||
}
|
||||
for (VertexFormatElement vertexformatelement : this.getElements()) {
|
||||
vertexformatelement.clearBufferState();
|
||||
final List<VertexFormatElement> list = this.getElements();
|
||||
final int listSize = list.size();
|
||||
|
||||
for(int i = 0 ; i < listSize; ++i) {
|
||||
list.get(i).clearBufferState();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+68
-36
@@ -3,11 +3,8 @@
|
||||
* License terms: https://www.lwjgl.org/license
|
||||
*/
|
||||
|
||||
package net.coderbot.iris.gl;
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import net.coderbot.iris.Iris;
|
||||
import org.lwjgl.opengl.AMDDebugOutput;
|
||||
import org.lwjgl.opengl.AMDDebugOutputCallback;
|
||||
import org.lwjgl.opengl.ARBDebugOutput;
|
||||
@@ -21,6 +18,7 @@ import org.lwjgl.opengl.KHRDebugCallback;
|
||||
import java.io.PrintStream;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
import static org.lwjgl.opengl.ARBDebugOutput.glDebugMessageCallbackARB;
|
||||
|
||||
public final class GLDebug {
|
||||
@@ -30,7 +28,7 @@ public final class GLDebug {
|
||||
*/
|
||||
public static int setupDebugMessageCallback() {
|
||||
if (Thread.currentThread() != GLStateManager.getMainThread()) {
|
||||
AngelicaTweaker.LOGGER.warn("setupDebugMessageCallback called from non-main thread!");
|
||||
LOGGER.warn("setupDebugMessageCallback called from non-main thread!");
|
||||
return 0;
|
||||
}
|
||||
return setupDebugMessageCallback(System.err);
|
||||
@@ -64,7 +62,7 @@ public final class GLDebug {
|
||||
return throwable;
|
||||
}
|
||||
|
||||
private static void printTrace(PrintStream stream) {
|
||||
public static void printTrace(PrintStream stream) {
|
||||
trace(new Consumer<String>() {
|
||||
boolean first = true;
|
||||
|
||||
@@ -84,8 +82,8 @@ public final class GLDebug {
|
||||
* @return 0 for failure, 1 for success, 2 for restart required.
|
||||
*/
|
||||
public static int setupDebugMessageCallback(PrintStream stream) {
|
||||
if (Iris.capabilities.OpenGL43 || Iris.capabilities.GL_KHR_debug) {
|
||||
Iris.logger.info("[GL] Using OpenGL 4.3 for error logging.");
|
||||
if (GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_KHR_debug) {
|
||||
LOGGER.info("[GL] Using OpenGL 4.3 for error logging.");
|
||||
KHRDebugCallback proc = new KHRDebugCallback((source, type, id, severity, message) -> {
|
||||
stream.println("[LWJGL] OpenGL debug message");
|
||||
printDetail(stream, "ID", String.format("0x%X", id));
|
||||
@@ -102,13 +100,13 @@ public final class GLDebug {
|
||||
GL43.glDebugMessageCallback(proc);
|
||||
|
||||
if ((GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & GL43.GL_CONTEXT_FLAG_DEBUG_BIT) == 0) {
|
||||
Iris.logger.warn("[GL] Warning: A non-debug context may not produce any debug output.");
|
||||
LOGGER.warn("[GL] Warning: A non-debug context may not produce any debug output.");
|
||||
GL11.glEnable(GL43.GL_DEBUG_OUTPUT);
|
||||
return 2;
|
||||
}
|
||||
return 1;
|
||||
} else if (Iris.capabilities.GL_ARB_debug_output) {
|
||||
Iris.logger.info("[GL] Using ARB_debug_output for error logging.");
|
||||
} else if (GLStateManager.capabilities.GL_ARB_debug_output) {
|
||||
LOGGER.info("[GL] Using ARB_debug_output for error logging.");
|
||||
ARBDebugOutputCallback proc = new ARBDebugOutputCallback((source, type, id, severity, message) -> {
|
||||
stream.println("[LWJGL] ARB_debug_output message");
|
||||
printDetail(stream, "ID", String.format("0x%X", id));
|
||||
@@ -124,8 +122,8 @@ public final class GLDebug {
|
||||
ARBDebugOutput.glDebugMessageControlARB(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_NOTIFICATION, null, false);
|
||||
ARBDebugOutput.glDebugMessageCallbackARB(proc);
|
||||
return 1;
|
||||
} else if (Iris.capabilities.GL_AMD_debug_output) {
|
||||
Iris.logger.info("[GL] Using AMD_debug_output for error logging.");
|
||||
} else if (GLStateManager.capabilities.GL_AMD_debug_output) {
|
||||
LOGGER.info("[GL] Using AMD_debug_output for error logging.");
|
||||
AMDDebugOutputCallback proc = new AMDDebugOutputCallback((id, category, severity, message) -> {
|
||||
stream.println("[LWJGL] AMD_debug_output message");
|
||||
printDetail(stream, "ID", String.format("0x%X", id));
|
||||
@@ -141,29 +139,29 @@ public final class GLDebug {
|
||||
AMDDebugOutput.glDebugMessageCallbackAMD(proc);
|
||||
return 1;
|
||||
} else {
|
||||
Iris.logger.info("[GL] No debug output implementation is available, cannot return debug info.");
|
||||
LOGGER.info("[GL] No debug output implementation is available, cannot return debug info.");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
public static int disableDebugMessages() {
|
||||
if (Iris.capabilities.OpenGL43) {
|
||||
if (GLStateManager.capabilities.OpenGL43) {
|
||||
GL43.glDebugMessageCallback(null);
|
||||
return 1;
|
||||
} else if (Iris.capabilities.GL_KHR_debug) {
|
||||
} else if (GLStateManager.capabilities.GL_KHR_debug) {
|
||||
KHRDebug.glDebugMessageCallback(null);
|
||||
if (Iris.capabilities.OpenGL30 && (GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & 2) == 0) {
|
||||
if (GLStateManager.capabilities.OpenGL30 && (GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & 2) == 0) {
|
||||
GL11.glDisable(GL43.GL_DEBUG_OUTPUT);
|
||||
}
|
||||
return 1;
|
||||
} else if (Iris.capabilities.GL_ARB_debug_output) {
|
||||
} else if (GLStateManager.capabilities.GL_ARB_debug_output) {
|
||||
glDebugMessageCallbackARB(null);
|
||||
return 1;
|
||||
} else if (Iris.capabilities.GL_AMD_debug_output) {
|
||||
} else if (GLStateManager.capabilities.GL_AMD_debug_output) {
|
||||
AMDDebugOutput.glDebugMessageCallbackAMD(null);
|
||||
return 1;
|
||||
} else {
|
||||
Iris.logger.info("[GL] No debug output implementation is available, cannot disable debug info.");
|
||||
LOGGER.info("[GL] No debug output implementation is available, cannot disable debug info.");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -273,14 +271,17 @@ public final class GLDebug {
|
||||
|
||||
private static DebugState debugState;
|
||||
|
||||
private static interface DebugState {
|
||||
private interface DebugState {
|
||||
void nameObject(int id, int object, String name);
|
||||
void pushGroup(int id, String name);
|
||||
void pushGroup(String name);
|
||||
void popGroup();
|
||||
void debugMessage(String name);
|
||||
}
|
||||
|
||||
private static class KHRDebugState implements DebugState {
|
||||
private boolean hasGroup;
|
||||
private static final int ID = 0;
|
||||
private int depth = 0;
|
||||
private static final int maxDepth = GL11.glGetInteger(KHRDebug.GL_MAX_DEBUG_GROUP_STACK_DEPTH);
|
||||
|
||||
@Override
|
||||
public void nameObject(int id, int object, String name) {
|
||||
@@ -288,19 +289,28 @@ public final class GLDebug {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void pushGroup(int id, String name) {
|
||||
KHRDebug.glPushDebugGroup(KHRDebug.GL_DEBUG_SOURCE_APPLICATION, id, name);
|
||||
hasGroup = true;
|
||||
public void pushGroup(String name) {
|
||||
depth++;
|
||||
if (depth > maxDepth) {
|
||||
throw new RuntimeException("Stack overflow");
|
||||
}
|
||||
KHRDebug.glPushDebugGroup(KHRDebug.GL_DEBUG_SOURCE_APPLICATION, ID, name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void popGroup() {
|
||||
if (hasGroup) {
|
||||
KHRDebug.glPopDebugGroup();
|
||||
hasGroup = false;
|
||||
}
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
throw new RuntimeException("Stack underflow");
|
||||
}
|
||||
KHRDebug.glPopDebugGroup();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void debugMessage(String message) {
|
||||
KHRDebug.glDebugMessageInsert(KHRDebug.GL_DEBUG_SOURCE_APPLICATION, KHRDebug.GL_DEBUG_TYPE_MARKER, ID, KHRDebug.GL_DEBUG_SEVERITY_NOTIFICATION, message);
|
||||
}
|
||||
}
|
||||
|
||||
private static class UnsupportedDebugState implements DebugState {
|
||||
@Override
|
||||
@@ -308,16 +318,21 @@ public final class GLDebug {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void pushGroup(int id, String name) {
|
||||
public void pushGroup(String name) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void popGroup() {
|
||||
}
|
||||
}
|
||||
|
||||
public static void initRenderer() {
|
||||
if (Iris.capabilities.GL_KHR_debug || Iris.capabilities.OpenGL43) {
|
||||
@Override
|
||||
public void debugMessage(String name) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public static void initDebugState() {
|
||||
if (GLStateManager.capabilities.GL_KHR_debug || GLStateManager.capabilities.OpenGL43) {
|
||||
debugState = new KHRDebugState();
|
||||
} else {
|
||||
debugState = new UnsupportedDebugState();
|
||||
@@ -325,6 +340,23 @@ public final class GLDebug {
|
||||
}
|
||||
|
||||
public static void nameObject(int id, int object, String name) {
|
||||
debugState.nameObject(id, object, name);
|
||||
if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
|
||||
debugState.nameObject(id, object, name);
|
||||
}
|
||||
}
|
||||
public static void pushGroup(String group) {
|
||||
if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
|
||||
debugState.pushGroup(group);
|
||||
}
|
||||
}
|
||||
public static void popGroup() {
|
||||
if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
|
||||
debugState.popGroup();
|
||||
}
|
||||
}
|
||||
public static void debugMessage(String message) {
|
||||
if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
|
||||
debugState.debugMessage(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -16,6 +16,9 @@ import com.gtnewhorizons.angelica.glsm.states.Color4;
|
||||
import com.gtnewhorizons.angelica.glsm.states.ISettableState;
|
||||
import com.gtnewhorizons.angelica.glsm.states.TextureBinding;
|
||||
import com.gtnewhorizons.angelica.glsm.states.TextureUnitArray;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfo;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureTracker;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
@@ -33,8 +36,6 @@ import net.coderbot.iris.gl.blending.DepthColorStorage;
|
||||
import net.coderbot.iris.gl.state.StateUpdateNotifiers;
|
||||
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
|
||||
import net.coderbot.iris.samplers.IrisSamplers;
|
||||
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;
|
||||
@@ -45,11 +46,15 @@ import org.joml.Vector3f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.LWJGLException;
|
||||
import org.lwjgl.opengl.ARBMultitexture;
|
||||
import org.lwjgl.opengl.ContextCapabilities;
|
||||
import org.lwjgl.opengl.Drawable;
|
||||
import org.lwjgl.opengl.EXTTextureFilterAnisotropic;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL14;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GLContext;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.DoubleBuffer;
|
||||
@@ -58,12 +63,15 @@ import java.nio.IntBuffer;
|
||||
import java.util.AbstractMap;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.function.IntSupplier;
|
||||
|
||||
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 ContextCapabilities capabilities;
|
||||
|
||||
public static 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);
|
||||
@@ -124,9 +132,10 @@ public class GLStateManager {
|
||||
private static final Map<IStateStack<?>, ISettableState<?>> glListStates = new Object2ObjectArrayMap<>();
|
||||
private static final Int2ObjectMap<Set<Map.Entry<IStateStack<?>, ISettableState<?>>>> glListChanges = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
private static boolean hudCaching$blendEnabled;
|
||||
|
||||
public static void init() {
|
||||
capabilities = GLContext.getCapabilities();
|
||||
RenderSystem.initRenderer();
|
||||
|
||||
if (AngelicaConfig.enableIris) {
|
||||
StateUpdateNotifiers.blendFuncNotifier = listener -> blendFuncListener = listener;
|
||||
StateUpdateNotifiers.fogToggleNotifier = listener -> fogToggleListener = listener;
|
||||
@@ -138,8 +147,18 @@ public class GLStateManager {
|
||||
if(BYPASS_CACHE) {
|
||||
LOGGER.info("GLStateManager cache bypassed");
|
||||
}
|
||||
if(AngelicaMod.lwjglDebug) {
|
||||
LOGGER.info("Enabling additional LWJGL debug output");
|
||||
|
||||
GLDebug.setupDebugMessageCallback();
|
||||
GLDebug.initDebugState();
|
||||
|
||||
GLDebug.debugMessage("Angelica Debug Annotator Initialized");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
public static void assertMainThread() {
|
||||
if (Thread.currentThread() != CurrentThread && !runningSplash) {
|
||||
LOGGER.info("Call from not the Current Thread! - " + Thread.currentThread().getName() + " Current thread: " + CurrentThread.getName());
|
||||
@@ -151,13 +170,13 @@ public class GLStateManager {
|
||||
switch (cap) {
|
||||
case GL11.GL_ALPHA_TEST -> enableAlphaTest();
|
||||
case GL11.GL_BLEND -> enableBlend();
|
||||
case GL11.GL_DEPTH_TEST -> enableDepthTest();
|
||||
case GL11.GL_CULL_FACE -> enableCull();
|
||||
case GL11.GL_LIGHTING -> enableLighting();
|
||||
case GL12.GL_RESCALE_NORMAL -> enableRescaleNormal();
|
||||
case GL11.GL_TEXTURE_2D -> enableTexture();
|
||||
case GL11.GL_DEPTH_TEST -> enableDepthTest();
|
||||
case GL11.GL_FOG -> enableFog();
|
||||
case GL11.GL_LIGHTING -> enableLighting();
|
||||
case GL11.GL_SCISSOR_TEST -> enableScissorTest();
|
||||
case GL11.GL_TEXTURE_2D -> enableTexture();
|
||||
case GL12.GL_RESCALE_NORMAL -> enableRescaleNormal();
|
||||
default -> GL11.glEnable(cap);
|
||||
}
|
||||
}
|
||||
@@ -166,17 +185,99 @@ public class GLStateManager {
|
||||
switch (cap) {
|
||||
case GL11.GL_ALPHA_TEST -> disableAlphaTest();
|
||||
case GL11.GL_BLEND -> disableBlend();
|
||||
case GL11.GL_DEPTH_TEST -> disableDepthTest();
|
||||
case GL11.GL_CULL_FACE -> disableCull();
|
||||
case GL11.GL_LIGHTING -> disableLighting();
|
||||
case GL12.GL_RESCALE_NORMAL -> disableRescaleNormal();
|
||||
case GL11.GL_TEXTURE_2D -> disableTexture();
|
||||
case GL11.GL_DEPTH_TEST -> disableDepthTest();
|
||||
case GL11.GL_FOG -> disableFog();
|
||||
case GL11.GL_LIGHTING -> disableLighting();
|
||||
case GL11.GL_SCISSOR_TEST -> disableScissorTest();
|
||||
case GL11.GL_TEXTURE_2D -> disableTexture();
|
||||
case GL12.GL_RESCALE_NORMAL -> disableRescaleNormal();
|
||||
default -> GL11.glDisable(cap);
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean glIsEnabled(int cap) {
|
||||
return switch (cap) {
|
||||
case GL11.GL_ALPHA_TEST -> alphaTest.isEnabled();
|
||||
case GL11.GL_BLEND -> blendMode.isEnabled();
|
||||
case GL11.GL_CULL_FACE -> cullState.isEnabled();
|
||||
case GL11.GL_DEPTH_TEST -> depthTest.isEnabled();
|
||||
case GL11.GL_FOG -> fogMode.isEnabled();
|
||||
case GL11.GL_LIGHTING -> lightingState.isEnabled();
|
||||
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
|
||||
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.topInt()).isEnabled();
|
||||
case GL12.GL_RESCALE_NORMAL -> rescaleNormalState.isEnabled();
|
||||
default -> GL11.glIsEnabled(cap);
|
||||
};
|
||||
}
|
||||
|
||||
public static boolean glGetBoolean(int pname) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
return GL11.glGetBoolean(pname);
|
||||
}
|
||||
return switch (pname) {
|
||||
case GL11.GL_ALPHA_TEST -> alphaTest.isEnabled();
|
||||
case GL11.GL_BLEND -> blendMode.isEnabled();
|
||||
case GL11.GL_CULL_FACE -> cullState.isEnabled();
|
||||
case GL11.GL_DEPTH_TEST -> depthTest.isEnabled();
|
||||
case GL11.GL_DEPTH_WRITEMASK -> depthState.isMask();
|
||||
case GL11.GL_FOG -> fogMode.isEnabled();
|
||||
case GL11.GL_LIGHTING -> lightingState.isEnabled();
|
||||
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
|
||||
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.topInt()).isEnabled();
|
||||
case GL12.GL_RESCALE_NORMAL -> rescaleNormalState.isEnabled();
|
||||
default -> GL11.glGetBoolean(pname);
|
||||
};
|
||||
}
|
||||
|
||||
private static void glGetBoolean(int pname, ByteBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
GL11.glGetBoolean(pname, params);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (pname) {
|
||||
case GL11.GL_COLOR_WRITEMASK -> {
|
||||
params.put((byte) (colorMask.red ? GL11.GL_TRUE : GL11.GL_FALSE));
|
||||
params.put((byte) (colorMask.green ? GL11.GL_TRUE : GL11.GL_FALSE));
|
||||
params.put((byte) (colorMask.blue ? GL11.GL_TRUE : GL11.GL_FALSE));
|
||||
params.put((byte) (colorMask.alpha ? GL11.GL_TRUE : GL11.GL_FALSE));
|
||||
}
|
||||
default -> GL11.glGetBoolean(pname, params);
|
||||
}
|
||||
}
|
||||
|
||||
public static int glGetInteger(int pname) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
return GL11.glGetInteger(pname);
|
||||
}
|
||||
|
||||
return switch (pname) {
|
||||
case GL11.GL_TEXTURE_BINDING_2D -> getBoundTexture();
|
||||
case GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
|
||||
case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
|
||||
case GL14.GL_BLEND_SRC_ALPHA -> blendState.getSrcAlpha();
|
||||
case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
|
||||
case GL11.GL_DEPTH_FUNC -> depthState.getFunc();
|
||||
case GL11.GL_LIST_MODE -> glListMode;
|
||||
case GL11.GL_MATRIX_MODE -> matrixMode.getMode();
|
||||
|
||||
default -> GL11.glGetInteger(pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static void glGetInteger(int pname, IntBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
GL11.glGetInteger(pname, params);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (pname) {
|
||||
case GL11.GL_VIEWPORT -> viewportState.get(params);
|
||||
default -> GL11.glGetInteger(pname, params);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glGetFloat(int pname, FloatBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
GL11.glGetFloat(pname, params);
|
||||
@@ -187,6 +288,7 @@ public class GLStateManager {
|
||||
case GL11.GL_MODELVIEW_MATRIX -> modelViewMatrix.get(params);
|
||||
case GL11.GL_PROJECTION_MATRIX -> projectionMatrix.get(params);
|
||||
case GL11.GL_TEXTURE_MATRIX -> textureMatrix.get(params);
|
||||
case GL11.GL_COLOR_CLEAR_VALUE -> clearColor.get(params);
|
||||
default -> GL11.glGetFloat(pname, params);
|
||||
}
|
||||
}
|
||||
@@ -204,7 +306,6 @@ public class GLStateManager {
|
||||
return;
|
||||
}
|
||||
}
|
||||
hudCaching$blendEnabled = true;
|
||||
blendMode.enable();
|
||||
}
|
||||
|
||||
@@ -215,7 +316,6 @@ public class GLStateManager {
|
||||
return;
|
||||
}
|
||||
}
|
||||
hudCaching$blendEnabled = false;
|
||||
blendMode.disable();
|
||||
}
|
||||
|
||||
@@ -299,36 +399,24 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glColor4f(float red, float green, float blue, float alpha) {
|
||||
if (!hudCaching$blendEnabled && HUDCaching.renderingCacheOverride && alpha < 1f) {
|
||||
alpha = 1f;
|
||||
}
|
||||
if (changeColor(red, green, blue, alpha)) {
|
||||
GL11.glColor4f(red, green, blue, alpha);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glColor4d(double red, double green, double blue, double alpha) {
|
||||
if (!hudCaching$blendEnabled && HUDCaching.renderingCacheOverride && alpha < 1d) {
|
||||
alpha = 1d;
|
||||
}
|
||||
if (changeColor((float) red, (float) green, (float) blue, (float) alpha)) {
|
||||
GL11.glColor4d(red, green, blue, alpha);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glColor4b(byte red, byte green, byte blue, byte alpha) {
|
||||
if (!hudCaching$blendEnabled && HUDCaching.renderingCacheOverride && alpha < Byte.MAX_VALUE) {
|
||||
alpha = Byte.MAX_VALUE;
|
||||
}
|
||||
if (changeColor(b2f(red), b2f(green), b2f(blue), b2f(alpha))) {
|
||||
GL11.glColor4b(red, green, blue, alpha);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glColor4ub(byte red, byte green, byte blue, byte alpha) {
|
||||
if (!hudCaching$blendEnabled && HUDCaching.renderingCacheOverride && alpha < Byte.MAX_VALUE) {
|
||||
alpha = Byte.MAX_VALUE;
|
||||
}
|
||||
if (changeColor(ub2f(red), ub2f(green), ub2f(blue), ub2f(alpha))) {
|
||||
GL11.glColor4ub(red, green, blue, alpha);
|
||||
}
|
||||
@@ -464,7 +552,11 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static int getBoundTexture() {
|
||||
return textures.getTextureUnitBindings(activeTextureUnit.topInt()).getBinding();
|
||||
return getBoundTexture(activeTextureUnit.topInt());
|
||||
}
|
||||
|
||||
public static int getBoundTexture(int unit) {
|
||||
return textures.getTextureUnitBindings(unit).getBinding();
|
||||
}
|
||||
|
||||
public static void glBindTexture(int target, int texture) {
|
||||
@@ -479,48 +571,37 @@ public class GLStateManager {
|
||||
if (GLStateManager.BYPASS_CACHE || textureUnit.getBinding() != texture || runningSplash) {
|
||||
GL11.glBindTexture(target, texture);
|
||||
textureUnit.setBinding(texture);
|
||||
if (AngelicaConfig.enableIris) {
|
||||
TextureTracker.INSTANCE.onBindTexture(texture);
|
||||
}
|
||||
TextureTracker.INSTANCE.onBindTexture(texture);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels) {
|
||||
if (AngelicaConfig.enableIris) {
|
||||
// Iris
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void glTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, ByteBuffer pixels) {
|
||||
if (AngelicaConfig.enableIris) {
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels != null ? pixels.asIntBuffer() : (IntBuffer) null);
|
||||
}
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels != null ? pixels.asIntBuffer() : (IntBuffer) null);
|
||||
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void glTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, long pixels_buffer_offset) {
|
||||
if (AngelicaConfig.enableIris) {
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels_buffer_offset);
|
||||
}
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels_buffer_offset);
|
||||
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels_buffer_offset);
|
||||
}
|
||||
|
||||
public static void glDeleteTextures(int id) {
|
||||
if (AngelicaConfig.enableIris) {
|
||||
iris$onDeleteTexture(id);
|
||||
}
|
||||
onDeleteTexture(id);
|
||||
|
||||
textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt()).setBinding(-1);
|
||||
GL11.glDeleteTextures(id);
|
||||
}
|
||||
|
||||
public static void glDeleteTextures(IntBuffer ids) {
|
||||
if (AngelicaConfig.enableIris) {
|
||||
for(int i = 0; i < ids.capacity(); i++) {
|
||||
iris$onDeleteTexture(ids.get(i));
|
||||
}
|
||||
for(int i = 0; i < ids.capacity(); i++) {
|
||||
onDeleteTexture(ids.get(i));
|
||||
}
|
||||
|
||||
textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt()).setBinding(-1);
|
||||
GL11.glDeleteTextures(ids);
|
||||
}
|
||||
@@ -580,8 +661,8 @@ public class GLStateManager {
|
||||
i = mipmap ? GL11.GL_NEAREST_MIPMAP_LINEAR : GL11.GL_NEAREST;
|
||||
j = GL11.GL_NEAREST;
|
||||
}
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, i);
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, j);
|
||||
glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, i);
|
||||
glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, j);
|
||||
}
|
||||
|
||||
public static void glDrawArrays(int mode, int first, int count) {
|
||||
@@ -716,10 +797,10 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
// Iris Functions
|
||||
private static void iris$onDeleteTexture(int id) {
|
||||
private static void onDeleteTexture(int id) {
|
||||
TextureTracker.INSTANCE.onDeleteTexture(id);
|
||||
TextureInfoCache.INSTANCE.onDeleteTexture(id);
|
||||
if (AngelicaConfig.enableIris) {
|
||||
TextureTracker.INSTANCE.onDeleteTexture(id);
|
||||
TextureInfoCache.INSTANCE.onDeleteTexture(id);
|
||||
PBRTextureManager.INSTANCE.onDeleteTexture(id);
|
||||
}
|
||||
}
|
||||
@@ -946,4 +1027,152 @@ public class GLStateManager {
|
||||
public static int getListMode() {
|
||||
return glListMode;
|
||||
}
|
||||
|
||||
|
||||
public static boolean updateTexParameteriCache(int target, int texture, int pname, int param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
return true;
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texture);
|
||||
switch (pname) {
|
||||
case GL11.GL_TEXTURE_MIN_FILTER -> {
|
||||
if(info.getMinFilter() == param) return false;
|
||||
info.setMinFilter(param);
|
||||
}
|
||||
case GL11.GL_TEXTURE_MAG_FILTER -> {
|
||||
if(info.getMagFilter() == param) return false;
|
||||
info.setMagFilter(param);
|
||||
}
|
||||
case GL11.GL_TEXTURE_WRAP_S -> {
|
||||
if(info.getWrapS() == param) return false;
|
||||
info.setWrapS(param);
|
||||
}
|
||||
case GL11.GL_TEXTURE_WRAP_T -> {
|
||||
if(info.getWrapT() == param) return false;
|
||||
info.setWrapT(param);
|
||||
}
|
||||
case GL12.GL_TEXTURE_MAX_LEVEL -> {
|
||||
if(info.getMaxLevel() == param) return false;
|
||||
info.setMaxLevel(param);
|
||||
}
|
||||
case GL12.GL_TEXTURE_MIN_LOD -> {
|
||||
if(info.getMinLod() == param) return false;
|
||||
info.setMinLod(param);
|
||||
}
|
||||
case GL12.GL_TEXTURE_MAX_LOD -> {
|
||||
if(info.getMaxLod() == param) return false;
|
||||
info.setMaxLod(param);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
public static void glTexParameter(int target, int pname, IntBuffer params) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE || params.remaining() != 1 ) {
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
return;
|
||||
}
|
||||
if(!updateTexParameteriCache(target, getBoundTexture(), pname, params.get(0))) return;
|
||||
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
}
|
||||
|
||||
public static void glTexParameter(int target, int pname, FloatBuffer params) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE || params.remaining() != 1 ) {
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
return;
|
||||
}
|
||||
if(!updateTexParameterfCache(target, getBoundTexture(), pname, params.get(0))) return;
|
||||
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
}
|
||||
|
||||
|
||||
public static void glTexParameteri(int target, int pname, int param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
GL11.glTexParameteri(target, pname, param);
|
||||
return;
|
||||
}
|
||||
if(!updateTexParameteriCache(target, getBoundTexture(), pname, param)) return;
|
||||
|
||||
GL11.glTexParameteri(target, pname, param);
|
||||
}
|
||||
|
||||
|
||||
public static boolean updateTexParameterfCache(int target, int texture, int pname, float param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
return true;
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texture);
|
||||
switch (pname) {
|
||||
case EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT -> {
|
||||
if(info.getMaxAnisotropy() == param) return false;
|
||||
info.setMaxAnisotropy(param);
|
||||
}
|
||||
case GL14.GL_TEXTURE_LOD_BIAS -> {
|
||||
if(info.getLodBias() == param) return false;
|
||||
info.setLodBias(param);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static void glTexParameterf(int target, int pname, float param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
GL11.glTexParameterf(target, pname, param);
|
||||
return;
|
||||
}
|
||||
if(!updateTexParameterfCache(getActiveTextureUnit(), target, pname, param)) return;
|
||||
|
||||
GL11.glTexParameterf(target, pname, param);
|
||||
}
|
||||
|
||||
public static int getTexParameterOrDefault(int texture, int pname, IntSupplier defaultSupplier) {
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texture);
|
||||
|
||||
return switch (pname) {
|
||||
case GL11.GL_TEXTURE_MIN_FILTER -> info.getMinFilter();
|
||||
case GL11.GL_TEXTURE_MAG_FILTER -> info.getMagFilter();
|
||||
case GL11.GL_TEXTURE_WRAP_S -> info.getWrapS();
|
||||
case GL11.GL_TEXTURE_WRAP_T -> info.getWrapT();
|
||||
case GL12.GL_TEXTURE_MAX_LEVEL -> info.getMaxLevel();
|
||||
case GL12.GL_TEXTURE_MIN_LOD -> info.getMinLod();
|
||||
case GL12.GL_TEXTURE_MAX_LOD -> info.getMaxLod();
|
||||
default -> defaultSupplier.getAsInt();
|
||||
};
|
||||
}
|
||||
public static int glGetTexParameteri(int target, int pname) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
return GL11.glGetTexParameteri(target, pname);
|
||||
}
|
||||
return getTexParameterOrDefault(getBoundTexture(), pname, () -> GL11.glGetTexParameteri(target, pname));
|
||||
}
|
||||
|
||||
public static float glGetTexParameterf(int target, int pname) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
return GL11.glGetTexParameterf(target, pname);
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(getBoundTexture());
|
||||
|
||||
return switch (pname) {
|
||||
case EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT -> info.getMaxAnisotropy();
|
||||
case GL14.GL_TEXTURE_LOD_BIAS -> info.getLodBias();
|
||||
default -> GL11.glGetTexParameterf(target, pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static int glGetTexLevelParameteri(int target, int level, int pname) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
return GL11.glGetTexLevelParameteri(target, level, pname);
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(getBoundTexture());
|
||||
|
||||
return switch (pname) {
|
||||
case GL11.GL_TEXTURE_WIDTH -> info.getWidth();
|
||||
case GL11.GL_TEXTURE_HEIGHT -> info.getHeight();
|
||||
case GL11.GL_TEXTURE_INTERNAL_FORMAT -> info.getInternalFormat();
|
||||
default -> GL11.glGetTexLevelParameteri(target, level, pname);
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,274 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSAARB;
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSAAccess;
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSACore;
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSAUnsupported;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Vector3i;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.EXTShaderImageLoadStore;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
import org.lwjgl.opengl.GL40;
|
||||
import org.lwjgl.opengl.GL42;
|
||||
import org.lwjgl.opengl.GL43;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
|
||||
/**
|
||||
* This class is responsible for abstracting calls to OpenGL and asserting that calls are run on the render thread.
|
||||
*/
|
||||
public class RenderSystem {
|
||||
private static DSAAccess dsaState;
|
||||
private static boolean hasMultibind;
|
||||
private static boolean supportsCompute;
|
||||
|
||||
private RenderSystem() {}
|
||||
|
||||
public static void initRenderer() {
|
||||
try {
|
||||
if (GLStateManager.capabilities.OpenGL45) {
|
||||
dsaState = new DSACore();
|
||||
LOGGER.info("OpenGL 4.5 detected, enabling DSA.");
|
||||
}
|
||||
hasMultibind = GLStateManager.capabilities.OpenGL45;
|
||||
|
||||
} catch (NoSuchFieldError ignored) {}
|
||||
try {
|
||||
if (dsaState == null && GLStateManager.capabilities.GL_ARB_direct_state_access) {
|
||||
dsaState = new DSAARB();
|
||||
LOGGER.info("ARB_direct_state_access detected, enabling DSA.");
|
||||
}
|
||||
} catch (NoSuchFieldError ignored) {}
|
||||
if (dsaState == null) {
|
||||
dsaState = new DSAUnsupported();
|
||||
}
|
||||
|
||||
try {
|
||||
hasMultibind |= GLStateManager.capabilities.GL_ARB_multi_bind;
|
||||
} catch (NoSuchFieldError ignored) {}
|
||||
|
||||
supportsCompute = supportsCompute();
|
||||
}
|
||||
|
||||
public static void generateMipmaps(int texture, int mipmapTarget) {
|
||||
dsaState.generateMipmaps(texture, mipmapTarget);
|
||||
}
|
||||
|
||||
public static void bindAttributeLocation(int program, int index, CharSequence name) {
|
||||
GL20.glBindAttribLocation(program, index, name);
|
||||
}
|
||||
|
||||
public static void texImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GLStateManager.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void uniformMatrix4fv(int location, boolean transpose, FloatBuffer matrix) {
|
||||
GL20.glUniformMatrix4(location, transpose, matrix);
|
||||
}
|
||||
|
||||
public static void copyTexImage2D(int target, int level, int internalFormat, int x, int y, int width, int height, int border) {
|
||||
GL11.glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
|
||||
}
|
||||
|
||||
public static void uniform1f(int location, float v0) {
|
||||
GL20.glUniform1f(location, v0);
|
||||
}
|
||||
|
||||
public static void uniform1i(int location, int v0) {
|
||||
GL20.glUniform1i(location, v0);
|
||||
}
|
||||
|
||||
public static void uniform2f(int location, float v0, float v1) {
|
||||
GL20.glUniform2f(location, v0, v1);
|
||||
}
|
||||
|
||||
public static void uniform2i(int location, int v0, int v1) {
|
||||
GL20.glUniform2i(location, v0, v1);
|
||||
}
|
||||
|
||||
public static void uniform3f(int location, float v0, float v1, float v2) {
|
||||
GL20.glUniform3f(location, v0, v1, v2);
|
||||
}
|
||||
|
||||
public static void uniform4f(int location, float v0, float v1, float v2, float v3) {
|
||||
GL20.glUniform4f(location, v0, v1, v2, v3);
|
||||
}
|
||||
|
||||
public static void uniform4i(int location, int v0, int v1, int v2, int v3) {
|
||||
GL20.glUniform4i(location, v0, v1, v2, v3);
|
||||
}
|
||||
|
||||
public static int getAttribLocation(int programId, String name) {
|
||||
return GL20.glGetAttribLocation(programId, name);
|
||||
}
|
||||
|
||||
public static int getUniformLocation(int programId, String name) {
|
||||
return GL20.glGetUniformLocation(programId, name);
|
||||
}
|
||||
|
||||
public static void texParameteriv(int texture, int target, int pname, IntBuffer params) {
|
||||
dsaState.texParameteriv(texture, target, pname, params);
|
||||
}
|
||||
|
||||
public static void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
|
||||
dsaState.copyTexSubImage2D(destTexture, target, i, i1, i2, i3, i4, width, height);
|
||||
}
|
||||
|
||||
public static void texParameteri(int texture, int target, int pname, int param) {
|
||||
dsaState.texParameteri(texture, target, pname, param);
|
||||
}
|
||||
|
||||
public static void texParameterf(int texture, int target, int pname, float param) {
|
||||
dsaState.texParameterf(texture, target, pname, param);
|
||||
}
|
||||
|
||||
public static String getProgramInfoLog(int program) {
|
||||
return GL20.glGetProgramInfoLog(program, GL20.glGetProgrami(program, GL20.GL_INFO_LOG_LENGTH));
|
||||
}
|
||||
|
||||
public static String getShaderInfoLog(int shader) {
|
||||
return GL20.glGetShaderInfoLog(shader, GL20.glGetShaderi(shader, GL20.GL_INFO_LOG_LENGTH));
|
||||
}
|
||||
|
||||
public static void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
dsaState.drawBuffers(framebuffer, buffers);
|
||||
}
|
||||
|
||||
public static void readBuffer(int framebuffer, int buffer) {
|
||||
dsaState.readBuffer(framebuffer, buffer);
|
||||
}
|
||||
|
||||
public static String getActiveUniform(int program, int index, int maxLength, IntBuffer sizeType) {
|
||||
return GL20.glGetActiveUniform(program, index, maxLength, sizeType);
|
||||
}
|
||||
|
||||
public static void readPixels(int x, int y, int width, int height, int format, int type, FloatBuffer pixels) {
|
||||
GL11.glReadPixels(x, y, width, height, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void bufferData(int target, FloatBuffer data, int usage) {
|
||||
GL15.glBufferData(target, data, usage);
|
||||
}
|
||||
|
||||
public static int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
return dsaState.bufferStorage(target, data, usage);
|
||||
}
|
||||
|
||||
public static void vertexAttrib4f(int index, float v0, float v1, float v2, float v3) {
|
||||
GL20.glVertexAttrib4f(index, v0, v1, v2, v3);
|
||||
}
|
||||
|
||||
public static void detachShader(int program, int shader) {
|
||||
GL20.glDetachShader(program, shader);
|
||||
}
|
||||
|
||||
public static void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
dsaState.framebufferTexture2D(fb, fbtarget, attachment, target, texture, levels);
|
||||
}
|
||||
|
||||
public static int getTexParameteri(int texture, int target, int pname) {
|
||||
return dsaState.getTexParameteri(texture, target, pname);
|
||||
}
|
||||
|
||||
public static void bindImageTexture(int unit, int texture, int level, boolean layered, int layer, int access, int format) {
|
||||
if (GLStateManager.capabilities.OpenGL42) {
|
||||
GL42.glBindImageTexture(unit, texture, level, layered, layer, access, format);
|
||||
} else {
|
||||
EXTShaderImageLoadStore.glBindImageTextureEXT(unit, texture, level, layered, layer, access, format);
|
||||
}
|
||||
}
|
||||
|
||||
public static int getMaxImageUnits() {
|
||||
if (GLStateManager.capabilities.OpenGL42) {
|
||||
return GL11.glGetInteger(GL42.GL_MAX_IMAGE_UNITS);
|
||||
} else if (GLStateManager.capabilities.GL_EXT_shader_image_load_store) {
|
||||
return GL11.glGetInteger(EXTShaderImageLoadStore.GL_MAX_IMAGE_UNITS_EXT);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
public static void getProgramiv(int program, int value, IntBuffer storage) {
|
||||
GL20.glGetProgram(program, value, storage);
|
||||
}
|
||||
|
||||
public static void dispatchCompute(int workX, int workY, int workZ) {
|
||||
GL43.glDispatchCompute(workX, workY, workZ);
|
||||
}
|
||||
|
||||
public static void dispatchCompute(Vector3i workGroups) {
|
||||
GL43.glDispatchCompute(workGroups.x, workGroups.y, workGroups.z);
|
||||
}
|
||||
|
||||
public static void memoryBarrier(int barriers) {
|
||||
if (supportsCompute) {
|
||||
GL42.glMemoryBarrier(barriers);
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean supportsBufferBlending() {
|
||||
return GLStateManager.capabilities.GL_ARB_draw_buffers_blend || GLStateManager.capabilities.OpenGL40;
|
||||
}
|
||||
|
||||
public static void disableBufferBlend(int buffer) {
|
||||
GL30.glDisablei(GL11.GL_BLEND, buffer);
|
||||
}
|
||||
|
||||
public static void enableBufferBlend(int buffer) {
|
||||
GL30.glEnablei(GL11.GL_BLEND, buffer);
|
||||
}
|
||||
|
||||
public static void blendFuncSeparatei(int buffer, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
|
||||
GL40.glBlendFuncSeparatei(buffer, srcRGB, dstRGB, srcAlpha, dstAlpha);
|
||||
}
|
||||
|
||||
public static void bindTextureToUnit(int unit, int texture) {
|
||||
dsaState.bindTextureToUnit(unit, texture);
|
||||
}
|
||||
|
||||
public static FloatBuffer PROJECTION_MATRIX_BUFFER = BufferUtils.createFloatBuffer(16);
|
||||
public static void setupProjectionMatrix(Matrix4f matrix) {
|
||||
GL11.glMatrixMode(GL11.GL_PROJECTION);
|
||||
GL11.glPushMatrix();
|
||||
matrix.get(0, PROJECTION_MATRIX_BUFFER);
|
||||
GL11.glLoadMatrix(PROJECTION_MATRIX_BUFFER);
|
||||
GL11.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
}
|
||||
|
||||
public static void restoreProjectionMatrix() {
|
||||
GL11.glMatrixMode(GL11.GL_PROJECTION);
|
||||
GL11.glPopMatrix();
|
||||
GL11.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
}
|
||||
|
||||
public static void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2, int bufferChoice, int filter) {
|
||||
dsaState.blitFramebuffer(source, dest, offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
public static int createFramebuffer() {
|
||||
return dsaState.createFramebuffer();
|
||||
}
|
||||
|
||||
public static int createTexture(int target) {
|
||||
return dsaState.createTexture(target);
|
||||
}
|
||||
|
||||
// TODO: Proper notification of compute support
|
||||
public static boolean supportsCompute() {
|
||||
try {
|
||||
return GLStateManager.capabilities.GL_ARB_compute_shader;
|
||||
} catch(Exception ignored) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -40,7 +40,9 @@ public class TessellatorManager {
|
||||
|
||||
public static void startCapturing() {
|
||||
if(currentlyCapturing.get()) throw new IllegalStateException("Tried to start capturing when already capturing!");
|
||||
if(capturingTessellator.get().getQuads().size() > 0) throw new IllegalStateException("Tried to start capturing with existing collected Quads!");
|
||||
final CapturingTessellator tess = capturingTessellator.get();
|
||||
if(tess.getQuads().size() > 0) throw new IllegalStateException("Tried to start capturing with existing collected Quads!");
|
||||
tess.storeTranslation();
|
||||
|
||||
currentlyCapturing.set(true);
|
||||
}
|
||||
@@ -59,6 +61,7 @@ public class TessellatorManager {
|
||||
|
||||
final List<Quad> quads = tess.getQuads();
|
||||
tess.discard();
|
||||
tess.restoreTranslation();
|
||||
|
||||
return quads;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
package com.gtnewhorizons.angelica.glsm.dsa;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.lwjgl.opengl.ARBDirectStateAccess;
|
||||
import org.lwjgl.opengl.GL45;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
public class DSAARB extends DSAUnsupported {
|
||||
|
||||
@Override
|
||||
public void generateMipmaps(int texture, int target) {
|
||||
ARBDirectStateAccess.glGenerateTextureMipmap(texture);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteri(int texture, int target, int pname, int param) {
|
||||
if(!GLStateManager.updateTexParameteriCache(target, texture, pname, param)) return;
|
||||
|
||||
ARBDirectStateAccess.glTextureParameteri(texture, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameterf(int texture, int target, int pname, float param) {
|
||||
if(!GLStateManager.updateTexParameterfCache(target, texture, pname, param)) return;
|
||||
|
||||
ARBDirectStateAccess.glTextureParameterf(texture, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteriv(int texture, int target, int pname, IntBuffer params) {
|
||||
ARBDirectStateAccess.glTextureParameter(texture, pname, params);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readBuffer(int framebuffer, int buffer) {
|
||||
ARBDirectStateAccess.glNamedFramebufferReadBuffer(framebuffer, buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
ARBDirectStateAccess.glNamedFramebufferDrawBuffers(framebuffer, buffers);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTexParameteri(int texture, int target, int pname) {
|
||||
return GLStateManager.getTexParameterOrDefault(texture, pname, () -> ARBDirectStateAccess.glGetTextureParameteri(texture, pname));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
|
||||
ARBDirectStateAccess.glCopyTextureSubImage2D(destTexture, i, i1, i2, i3, i4, width, height);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void bindTextureToUnit(int unit, int texture) {
|
||||
if(GLStateManager.getBoundTexture(unit) == texture) return;
|
||||
|
||||
if (texture == 0) {
|
||||
super.bindTextureToUnit(unit, texture);
|
||||
} else {
|
||||
ARBDirectStateAccess.glBindTextureUnit(unit, texture);
|
||||
GLStateManager.getTextures().getTextureUnitBindings(unit).setBinding(texture);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
final int buffer = GL45.glCreateBuffers();
|
||||
GL45.glNamedBufferData(buffer, data, usage);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2,
|
||||
int bufferChoice, int filter) {
|
||||
ARBDirectStateAccess.glBlitNamedFramebuffer(source, dest, offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
ARBDirectStateAccess.glNamedFramebufferTexture(fb, attachment, texture, levels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createFramebuffer() {
|
||||
return ARBDirectStateAccess.glCreateFramebuffers();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createTexture(int target) {
|
||||
return ARBDirectStateAccess.glCreateTextures(target);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package com.gtnewhorizons.angelica.glsm.dsa;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
public interface DSAAccess {
|
||||
void generateMipmaps(int texture, int target);
|
||||
|
||||
void texParameteri(int texture, int target, int pname, int param);
|
||||
void texParameterf(int texture, int target, int pname, float param);
|
||||
void texParameteriv(int texture, int target, int pname, IntBuffer params);
|
||||
|
||||
void readBuffer(int framebuffer, int buffer);
|
||||
|
||||
void drawBuffers(int framebuffer, IntBuffer buffers);
|
||||
|
||||
int getTexParameteri(int texture, int target, int pname);
|
||||
|
||||
void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height);
|
||||
|
||||
void bindTextureToUnit(int unit, int texture);
|
||||
|
||||
int bufferStorage(int target, FloatBuffer data, int usage);
|
||||
|
||||
void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2, int bufferChoice, int filter);
|
||||
|
||||
void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels);
|
||||
|
||||
int createFramebuffer();
|
||||
int createTexture(int target);
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package com.gtnewhorizons.angelica.glsm.dsa;
|
||||
|
||||
public class DSACore extends DSAARB {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
package com.gtnewhorizons.angelica.glsm.dsa;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
public class DSAUnsupported implements DSAAccess {
|
||||
|
||||
@Override
|
||||
public void generateMipmaps(int texture, int target) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GL30.glGenerateMipmap(target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteri(int texture, int target, int pname, int param) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GLStateManager.glTexParameteri(target, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameterf(int texture, int target, int pname, float param) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GLStateManager.glTexParameterf(target, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteriv(int texture, int target, int pname, IntBuffer params) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GLStateManager.glTexParameter(target, pname, params);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readBuffer(int framebuffer, int buffer) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GL11.glReadBuffer(buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GL20.glDrawBuffers(buffers);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTexParameteri(int texture, int target, int pname) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
return GLStateManager.glGetTexParameteri(target, pname);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
|
||||
final int previous = GLStateManager.getBoundTexture();
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, destTexture);
|
||||
GL11.glCopyTexSubImage2D(target, i, i1, i2, i3, i4, width, height);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, previous);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void bindTextureToUnit(int unit, int texture) {
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + unit);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
final int buffer = GL15.glGenBuffers();
|
||||
GL15.glBindBuffer(target, buffer);
|
||||
RenderSystem.bufferData(target, data, usage);
|
||||
GL15.glBindBuffer(target, 0);
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2,
|
||||
int bufferChoice, int filter) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_READ_FRAMEBUFFER, source);
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_DRAW_FRAMEBUFFER, dest);
|
||||
GL30.glBlitFramebuffer(offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(fbtarget, fb);
|
||||
GL30.glFramebufferTexture2D(fbtarget, attachment, target, texture, levels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createFramebuffer() {
|
||||
final int framebuffer = OpenGlHelper.func_153165_e/*glGenFramebuffers*/();
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
return framebuffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createTexture(int target) {
|
||||
final int texture = GL11.glGenTextures();
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
return texture;
|
||||
}
|
||||
}
|
||||
@@ -12,6 +12,15 @@ public class BlendState implements ISettableState<BlendState> {
|
||||
protected int srcAlpha = GL11.GL_ONE;
|
||||
protected int dstAlpha = GL11.GL_ZERO;
|
||||
|
||||
public BlendState() {}
|
||||
|
||||
public BlendState(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
this.srcRgb = srcRgb;
|
||||
this.dstRgb = dstRgb;
|
||||
this.srcAlpha = srcAlpha;
|
||||
this.dstAlpha = dstAlpha;
|
||||
}
|
||||
|
||||
@Override
|
||||
public BlendState set(BlendState state) {
|
||||
this.srcRgb = state.srcRgb;
|
||||
|
||||
@@ -3,6 +3,8 @@ package com.gtnewhorizons.angelica.glsm.states;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
@Getter @Setter
|
||||
public class Color4 implements ISettableState<Color4> {
|
||||
protected float red = 1.0F;
|
||||
@@ -30,6 +32,13 @@ public class Color4 implements ISettableState<Color4> {
|
||||
return this;
|
||||
}
|
||||
|
||||
public void get(FloatBuffer params) {
|
||||
params.put(0, red);
|
||||
params.put(1, green);
|
||||
params.put(2, blue);
|
||||
params.put(3, alpha);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameAs(Object state) {
|
||||
if (this == state) return true;
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
package com.gtnewhorizons.angelica.glsm.texture;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public class TextureInfo {
|
||||
|
||||
@Getter protected final int id;
|
||||
protected int internalFormat = -1;
|
||||
protected int width = -1;
|
||||
protected int height = -1;
|
||||
|
||||
@Getter @Setter protected int minFilter = GL11.GL_NEAREST_MIPMAP_LINEAR;
|
||||
@Getter @Setter protected int magFilter = GL11.GL_LINEAR;
|
||||
@Getter @Setter protected int wrapS = GL11.GL_REPEAT;
|
||||
@Getter @Setter protected int wrapT = GL11.GL_REPEAT;
|
||||
@Getter @Setter protected int maxLevel = 1000;
|
||||
@Getter @Setter protected int minLod = -1000;
|
||||
@Getter @Setter protected int maxLod = 1000;
|
||||
@Getter @Setter protected float lodBias = 0.0f;
|
||||
|
||||
@Getter @Setter protected float maxAnisotropy = 1.0f;
|
||||
|
||||
protected TextureInfo(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public int getInternalFormat() {
|
||||
if (internalFormat == -1) {
|
||||
internalFormat = fetchLevelParameter(GL11.GL_TEXTURE_INTERNAL_FORMAT);
|
||||
}
|
||||
return internalFormat;
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
if (width == -1) {
|
||||
width = fetchLevelParameter(GL11.GL_TEXTURE_WIDTH);
|
||||
}
|
||||
return width;
|
||||
}
|
||||
|
||||
public int getHeight() {
|
||||
if (height == -1) {
|
||||
height = fetchLevelParameter(GL11.GL_TEXTURE_HEIGHT);
|
||||
}
|
||||
return height;
|
||||
}
|
||||
|
||||
private int fetchLevelParameter(int pname) {
|
||||
// Keep track of what texture was bound before
|
||||
final int previousTextureBinding = GLStateManager.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
|
||||
// Bind this texture and grab the parameter from it.
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, id);
|
||||
final int parameter = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, 0, pname);
|
||||
|
||||
// Make sure to re-bind the previous texture to avoid issues.
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, previousTextureBinding);
|
||||
|
||||
return parameter;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
package com.gtnewhorizons.angelica.glsm.texture;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
public class TextureInfoCache {
|
||||
/**
|
||||
* Adapted from Iris for use in GLSM
|
||||
*/
|
||||
|
||||
public static final TextureInfoCache INSTANCE = new TextureInfoCache();
|
||||
|
||||
private final Int2ObjectMap<TextureInfo> cache = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
private TextureInfoCache() {
|
||||
}
|
||||
|
||||
public TextureInfo getInfo(int id) {
|
||||
return cache.computeIfAbsent(id, TextureInfo::new);
|
||||
}
|
||||
|
||||
public void onTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels) {
|
||||
if (level == 0) {
|
||||
final TextureInfo info = getInfo(GLStateManager.getBoundTexture());
|
||||
info.internalFormat = internalformat;
|
||||
info.width = width;
|
||||
info.height = height;
|
||||
}
|
||||
}
|
||||
public void onTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, long pixels_buffer_offset) {
|
||||
if (level == 0) {
|
||||
final TextureInfo info = getInfo(GLStateManager.getBoundTexture());
|
||||
info.internalFormat = internalformat;
|
||||
info.width = width;
|
||||
info.height = height;
|
||||
}
|
||||
}
|
||||
|
||||
public void onDeleteTexture(int id) {
|
||||
cache.remove(id);
|
||||
}
|
||||
|
||||
}
|
||||
+14
-7
@@ -1,16 +1,21 @@
|
||||
package net.coderbot.iris.texture;
|
||||
package com.gtnewhorizons.angelica.glsm.texture;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.state.StateUpdateNotifiers;
|
||||
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
|
||||
import net.minecraft.client.renderer.texture.AbstractTexture;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
public class TextureTracker {
|
||||
/**
|
||||
* Adapted from Iris for use in GLSM
|
||||
*/
|
||||
|
||||
public static final TextureTracker INSTANCE = new TextureTracker();
|
||||
|
||||
private static Runnable bindTextureListener;
|
||||
@@ -44,12 +49,14 @@ public class TextureTracker {
|
||||
if (bindTextureListener != null) {
|
||||
bindTextureListener.run();
|
||||
}
|
||||
WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
|
||||
if (pipeline != null) {
|
||||
pipeline.onBindTexture(id);
|
||||
}
|
||||
if(AngelicaConfig.enableIris) {
|
||||
final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
|
||||
if (pipeline != null) {
|
||||
pipeline.onBindTexture(id);
|
||||
}
|
||||
}
|
||||
// Reset texture state
|
||||
IrisRenderSystem.bindTextureToUnit(0, id);
|
||||
RenderSystem.bindTextureToUnit(0, id);
|
||||
lockBindCallback = false;
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.TessellatorManager;
|
||||
@@ -34,10 +35,7 @@ public class HUDCaching {
|
||||
public static Framebuffer framebuffer;
|
||||
static {
|
||||
framebuffer = new Framebuffer(0, 0, true);
|
||||
framebuffer.framebufferColor[0] = 0.0F;
|
||||
framebuffer.framebufferColor[1] = 0.0F;
|
||||
framebuffer.framebufferColor[2] = 0.0F;
|
||||
framebuffer.framebufferColor[3] = 0.0F;
|
||||
framebuffer.setFramebufferColor(0, 0, 0, 0);
|
||||
}
|
||||
private static boolean dirty = true;
|
||||
|
||||
@@ -112,30 +110,23 @@ public class HUDCaching {
|
||||
return;
|
||||
}
|
||||
|
||||
GLStateManager.enableDepthTest();
|
||||
ScaledResolution resolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
int width = resolution.getScaledWidth();
|
||||
int height = resolution.getScaledHeight();
|
||||
renderer.setupOverlayRendering();
|
||||
GLStateManager.enableBlend();
|
||||
|
||||
if (dirty) {
|
||||
dirty = false;
|
||||
checkFramebufferSizes(mc.displayWidth, mc.displayHeight);
|
||||
framebuffer.framebufferClear();
|
||||
resetFramebuffer(mc.displayWidth, mc.displayHeight);
|
||||
framebuffer.bindFramebuffer(false);
|
||||
GLStateManager.disableBlend();
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GLStateManager.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
GLStateManager.disableLighting();
|
||||
GLStateManager.disableFog();
|
||||
renderingCacheOverride = true;
|
||||
ingame.renderGameOverlay(partialTicks, hasScreen, mouseX, mouseY);
|
||||
renderingCacheOverride = false;
|
||||
mc.getFramebuffer().bindFramebuffer(false);
|
||||
GLStateManager.enableBlend();
|
||||
} else {
|
||||
renderer.setupOverlayRendering();
|
||||
}
|
||||
|
||||
ScaledResolution resolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
int width = resolution.getScaledWidth();
|
||||
int height = resolution.getScaledHeight();
|
||||
GLStateManager.enableBlend();
|
||||
|
||||
// reset the color that may be applied by some items
|
||||
GLStateManager.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
|
||||
@@ -148,8 +139,6 @@ public class HUDCaching {
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0);
|
||||
}
|
||||
|
||||
Tessellator tessellator = TessellatorManager.get();
|
||||
|
||||
if (ingame instanceof GuiIngameForge) {
|
||||
GuiIngameForgeAccessor guiForge = ((GuiIngameForgeAccessor) ingame);
|
||||
if (renderHelmetCaptured) {
|
||||
@@ -168,36 +157,46 @@ public class HUDCaching {
|
||||
}
|
||||
if (renderPortalCapturedTicks > 0)
|
||||
{
|
||||
gui.callFunc_130015_b(renderPortalCapturedTicks, width, height);
|
||||
}
|
||||
if (renderCrosshairsCaptured) {
|
||||
mc.getTextureManager().bindTexture(Gui.icons);
|
||||
GLStateManager.enableBlend();
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_ONE_MINUS_DST_COLOR, GL11.GL_ONE_MINUS_SRC_COLOR, GL11.GL_ONE, GL11.GL_ZERO);
|
||||
GLStateManager.enableAlphaTest();
|
||||
drawTexturedModalRect(tessellator, (width >> 1) - 7, (height >> 1) - 7);
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
|
||||
gui.callRenderPortal(renderPortalCapturedTicks, width, height);
|
||||
}
|
||||
}
|
||||
|
||||
// render cached frame
|
||||
Tessellator tessellator = TessellatorManager.get();
|
||||
GLStateManager.enableBlend();
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GLStateManager.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
framebuffer.bindFramebufferTexture();
|
||||
drawTexturedRect(tessellator, (float) resolution.getScaledWidth_double(), (float) resolution.getScaledHeight_double());
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
|
||||
|
||||
GLStateManager.enableDepthTest();
|
||||
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
|
||||
mc.getTextureManager().bindTexture(Gui.icons);
|
||||
}
|
||||
|
||||
/**
|
||||
* We are skipping certain render calls when rendering into cache,
|
||||
* however, we cannot skip the GL state changes. This will fix
|
||||
* the state before we start rendering
|
||||
*/
|
||||
public static void fixGLStateBeforeRenderingCache() {
|
||||
GLStateManager.glDepthMask(true);
|
||||
GLStateManager.enableDepthTest();
|
||||
GLStateManager.enableAlphaTest();
|
||||
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
|
||||
GLStateManager.disableBlend();
|
||||
}
|
||||
|
||||
private static void checkFramebufferSizes(int width, int height) {
|
||||
private static void resetFramebuffer(int width, int height) {
|
||||
if (framebuffer.framebufferWidth != width || framebuffer.framebufferHeight != height) {
|
||||
framebuffer.createBindFramebuffer(width, height);
|
||||
framebuffer.framebufferWidth = width;
|
||||
framebuffer.framebufferHeight = height;
|
||||
framebuffer.createBindFramebuffer(width, height);
|
||||
framebuffer.setFramebufferFilter(GL11.GL_NEAREST);
|
||||
} else {
|
||||
framebuffer.framebufferClear();
|
||||
}
|
||||
// copy depth buffer from MC
|
||||
OpenGlHelper.func_153171_g(GL30.GL_READ_FRAMEBUFFER, mc.getFramebuffer().framebufferObject);
|
||||
OpenGlHelper.func_153171_g(GL30.GL_DRAW_FRAMEBUFFER, framebuffer.framebufferObject);
|
||||
GL30.glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_STENCIL_BUFFER_BIT, GL11.GL_NEAREST);
|
||||
}
|
||||
|
||||
private static void drawTexturedRect(Tessellator tessellator, float width, float height) {
|
||||
@@ -214,13 +213,4 @@ public class HUDCaching {
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
}
|
||||
|
||||
private static void drawTexturedModalRect(Tessellator tessellator, int x, int y) {
|
||||
tessellator.startDrawingQuads();
|
||||
tessellator.addVertexWithUV(x, y + 16, 100.0, 0.0, 0.0625);
|
||||
tessellator.addVertexWithUV(x + 16, y + 16, 100.0, 0.0625, 0.0625);
|
||||
tessellator.addVertexWithUV(x + 16, y, 100.0, 0.0625, 0.0);
|
||||
tessellator.addVertexWithUV(x, y, 100.0, 0.0, 0.0);
|
||||
tessellator.draw();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -27,6 +27,7 @@ public enum Mixins {
|
||||
"angelica.MixinActiveRenderInfo"
|
||||
,"angelica.MixinEntityRenderer"
|
||||
,"angelica.MixinMinecraft"
|
||||
,"angelica.optimizations.MixinRendererLivingEntity"
|
||||
)
|
||||
),
|
||||
ANGELICA_VBO(
|
||||
@@ -47,7 +48,9 @@ public enum Mixins {
|
||||
|
||||
ANGELICA_ENABLE_DEBUG(new Builder("Angelica Debug").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
|
||||
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaMod.lwjglDebug).addMixinClasses(
|
||||
"angelica.debug.MixinSplashProgress"
|
||||
"angelica.debug.MixinProfiler"
|
||||
,"angelica.debug.MixinSplashProgress"
|
||||
,"angelica.debug.MixinTextureManager"
|
||||
)
|
||||
),
|
||||
|
||||
@@ -79,12 +82,6 @@ public enum Mixins {
|
||||
)
|
||||
),
|
||||
|
||||
SODIUM_STARTUP(new Builder("Start Sodium").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
|
||||
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.enableSodium && !AngelicaConfig.enableIris).addMixinClasses(
|
||||
"sodium.startup.MixinInitDebug"
|
||||
)
|
||||
),
|
||||
|
||||
SODIUM(new Builder("Sodium").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
|
||||
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.enableSodium).addMixinClasses(
|
||||
"sodium.MixinChunkProviderClient"
|
||||
@@ -152,12 +149,6 @@ 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(
|
||||
"angelica.textures.MixinTextureAtlasSprite"
|
||||
@@ -194,7 +185,7 @@ public enum Mixins {
|
||||
"angelica.animation.MixinRenderBlockFluid",
|
||||
"angelica.animation.MixinWorldRenderer",
|
||||
"angelica.animation.MixinRenderItem")),
|
||||
|
||||
|
||||
SPEEDUP_CAMPFIRE_BACKPORT_ANIMATIONS(new Builder("Add animation speedup support to Campfire Backport").setPhase(Phase.LATE)
|
||||
.addTargetedMod(TargetedMod.CAMPFIRE_BACKPORT).setSide(Side.CLIENT)
|
||||
.setApplyIf(() -> AngelicaConfig.speedupAnimations)
|
||||
|
||||
-12
@@ -1,14 +1,11 @@
|
||||
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;
|
||||
@@ -22,13 +19,4 @@ public class MixinActiveRenderInfo {
|
||||
RenderingState.INSTANCE.setProjectionMatrix(projection);
|
||||
RenderingState.INSTANCE.setModelViewMatrix(modelview);
|
||||
}
|
||||
|
||||
@Redirect(method = "updateRenderInfo", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glGetInteger(ILjava/nio/IntBuffer;)V"), remap = false)
|
||||
private static void angelica$glGetInteger(int pname, java.nio.IntBuffer params) {
|
||||
if(pname == GL11.GL_VIEWPORT) {
|
||||
GLStateManager.getViewportState().get(params);
|
||||
} else {
|
||||
GL11.glGetInteger(pname, params);
|
||||
}
|
||||
}
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.debug;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import net.minecraft.profiler.Profiler;
|
||||
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;
|
||||
|
||||
@Mixin(Profiler.class)
|
||||
public class MixinProfiler {
|
||||
@Inject(method = "startSection(Ljava/lang/String;)V", at = @At("HEAD"))
|
||||
private void debugStartSection(String name, CallbackInfo ci) {
|
||||
GLDebug.pushGroup("minecraft:" + name);
|
||||
}
|
||||
|
||||
@Inject(method = "endSection()V", at = @At("HEAD"))
|
||||
private void debugEndSection(CallbackInfo ci) {
|
||||
GLDebug.popGroup();
|
||||
}
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.debug;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import net.minecraft.client.renderer.texture.ITextureObject;
|
||||
import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.client.renderer.texture.TextureUtil;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
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.CallbackInfoReturnable;
|
||||
|
||||
@Mixin(TextureManager.class)
|
||||
public class MixinTextureManager {
|
||||
@Inject(method = "loadTexture", at = @At("RETURN"))
|
||||
private void onTextureLoad(ResourceLocation resource, ITextureObject texture, CallbackInfoReturnable<Boolean> cir) {
|
||||
if(texture != null && texture != TextureUtil.missingTexture) {
|
||||
final int curId = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture.getGlTextureId());
|
||||
GLDebug.nameObject(GL11.GL_TEXTURE, texture.getGlTextureId(), resource.toString());
|
||||
GL11.glBindTexture(GL11.GL_TEXTURE_2D, curId);
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-3
@@ -13,7 +13,6 @@ public interface GuiIngameAccessor {
|
||||
@Invoker
|
||||
void callRenderPumpkinBlur(int width, int height);
|
||||
|
||||
// render portal
|
||||
@Invoker
|
||||
void callFunc_130015_b(float partialTicks, int width, int height);
|
||||
@Invoker("func_130015_b")
|
||||
void callRenderPortal(float partialTicks, int width, int height);
|
||||
}
|
||||
+7
-2
@@ -1,10 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
|
||||
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraftforge.client.GuiIngameForge;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.gen.Invoker;
|
||||
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraftforge.client.GuiIngameForge;
|
||||
|
||||
@Mixin(GuiIngameForge.class)
|
||||
public interface GuiIngameForgeAccessor {
|
||||
|
||||
@@ -16,4 +18,7 @@ public interface GuiIngameForgeAccessor {
|
||||
|
||||
@Invoker(remap = false)
|
||||
void callRenderPortal(int width, int height, float partialTicks);
|
||||
|
||||
@Invoker(remap = false)
|
||||
void callBind(ResourceLocation res);
|
||||
}
|
||||
+15
-2
@@ -1,12 +1,15 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
|
||||
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import net.minecraftforge.client.GuiIngameForge;
|
||||
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 com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
|
||||
import net.minecraft.client.gui.Gui;
|
||||
import net.minecraftforge.client.GuiIngameForge;
|
||||
|
||||
@Mixin(GuiIngameForge.class)
|
||||
public class MixinGuiIngameForge_HUDCaching {
|
||||
@Inject(method = "renderGameOverlay", at = @At("HEAD"))
|
||||
@@ -23,6 +26,7 @@ public class MixinGuiIngameForge_HUDCaching {
|
||||
private void angelica$captureRenderCrosshair(CallbackInfo ci) {
|
||||
if (HUDCaching.renderingCacheOverride) {
|
||||
HUDCaching.renderCrosshairsCaptured = true;
|
||||
HUDCaching.fixGLStateBeforeRenderingCache();
|
||||
ci.cancel();
|
||||
}
|
||||
}
|
||||
@@ -42,4 +46,13 @@ public class MixinGuiIngameForge_HUDCaching {
|
||||
ci.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
@Inject(method = "renderBossHealth", at = @At("HEAD"))
|
||||
private void angelica$bindBossHealthTexture(CallbackInfo ci) {
|
||||
// boss health texture is bind in renderCrosshairs
|
||||
// but HUD caching skips rendering crosshairs when rendering into cache
|
||||
if (HUDCaching.renderingCacheOverride) {
|
||||
((GuiIngameForgeAccessor) this).callBind(Gui.icons);
|
||||
}
|
||||
}
|
||||
}
|
||||
+14
@@ -6,7 +6,10 @@ import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
|
||||
import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
|
||||
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import net.minecraft.client.gui.GuiIngame;
|
||||
|
||||
@Mixin(GuiIngame.class)
|
||||
@@ -44,4 +47,15 @@ public class MixinGuiIngame_HUDCaching {
|
||||
ci.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
@WrapOperation(method = "func_96136_a", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/FontRenderer;drawString(Ljava/lang/String;III)I"))
|
||||
private int angelica$fixScoreboardTextAlpha(FontRenderer fontRenderer, String text, int x, int y, int color, Operation<Integer> op) {
|
||||
// Vanilla uses 0x20 for the alpha but it looks like 0xFF for some reason
|
||||
// here we just make it 0xFF so it doesn't cause issues
|
||||
if (HUDCaching.renderingCacheOverride) {
|
||||
color |= 0xFF000000;
|
||||
}
|
||||
return op.call(fontRenderer, text, x, y, color);
|
||||
}
|
||||
|
||||
}
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.optimizations;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import net.minecraft.client.renderer.entity.RendererLivingEntity;
|
||||
import net.minecraft.entity.EntityLiving;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.util.EnumChatFormatting;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Overwrite;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
|
||||
@Mixin(RendererLivingEntity.class)
|
||||
public abstract class MixinRendererLivingEntity {
|
||||
|
||||
@Shadow protected abstract float getDeathMaxRotation(EntityLivingBase entity);
|
||||
|
||||
/**
|
||||
* @author mitchej123
|
||||
* @reason The vanilla method triggers way too many allocations for no good reason
|
||||
*/
|
||||
@Overwrite
|
||||
protected void rotateCorpse(EntityLivingBase entity, float p_77043_2_, float p_77043_3_, float partialTicks) {
|
||||
GLStateManager.glRotatef(180.0F - p_77043_3_, 0.0F, 1.0F, 0.0F);
|
||||
|
||||
if (entity.deathTime > 0) {
|
||||
float f3 = ((float)entity.deathTime + partialTicks - 1.0F) / 20.0F * 1.6F;
|
||||
f3 = MathHelper.sqrt_float(f3);
|
||||
|
||||
if (f3 > 1.0F) {
|
||||
f3 = 1.0F;
|
||||
}
|
||||
|
||||
GL11.glRotatef(f3 * this.getDeathMaxRotation(entity), 0.0F, 0.0F, 1.0F);
|
||||
}
|
||||
else if ((entity instanceof EntityLiving entityLiving) && entityLiving.hasCustomNameTag() || (entity instanceof EntityPlayer entityPlayer) && !entityPlayer.getHideCape()) {
|
||||
|
||||
final String s = EnumChatFormatting.getTextWithoutFormattingCodes(entity.getCommandSenderName());
|
||||
|
||||
if ((s.equals("Dinnerbone") || s.equals("Grumm"))) {
|
||||
GLStateManager.glTranslatef(0.0F, entity.height + 0.1F, 0.0F);
|
||||
GLStateManager.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.shaders.startup;
|
||||
|
||||
import net.coderbot.iris.texture.TextureTracker;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureTracker;
|
||||
import net.minecraft.client.renderer.texture.AbstractTexture;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
|
||||
-5
@@ -3,8 +3,6 @@ package com.gtnewhorizons.angelica.mixins.early.shaders.startup;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.GLDebug;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
@@ -20,9 +18,6 @@ public class MixinInitRenderer {
|
||||
return;
|
||||
}
|
||||
|
||||
Iris.identifyCapabilities();
|
||||
GLDebug.initRenderer();
|
||||
IrisRenderSystem.initRenderer();
|
||||
Iris.onRenderSystemInit();
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.RenderGlobal;
|
||||
import net.minecraft.client.settings.GameSettings;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
@@ -34,9 +35,8 @@ public class MixinMinecraft {
|
||||
return SodiumClientMod.options().quality.grassQuality.isFancy();
|
||||
}
|
||||
|
||||
@Inject(method = "checkGLError", at = @At(value = "HEAD"), cancellable = true)
|
||||
private void sodium$checkGLError(CallbackInfo ci) {
|
||||
if(SodiumClientMod.options().performance.useNoErrorGLContext)
|
||||
ci.cancel();
|
||||
@Redirect(method = "checkGLError", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glGetError()I"))
|
||||
private int sodium$checkGLError() {
|
||||
return SodiumClientMod.options().performance.useNoErrorGLContext ? 0 : GL11.glGetError();
|
||||
}
|
||||
}
|
||||
-26
@@ -1,26 +0,0 @@
|
||||
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;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
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;
|
||||
|
||||
@Mixin(OpenGlHelper.class)
|
||||
public class MixinInitDebug {
|
||||
@Inject(method = "initializeTextures", at = @At("RETURN"))
|
||||
private static void sodium$initIrisDebug(CallbackInfo ci) {
|
||||
if (Thread.currentThread() != GLStateManager.getMainThread()) {
|
||||
AngelicaTweaker.LOGGER.warn("Renderer initialization called from non-main thread!");
|
||||
return;
|
||||
}
|
||||
// Temp -- move this into common debug code
|
||||
Iris.identifyCapabilities();
|
||||
Iris.setDebug(AngelicaMod.lwjglDebug);
|
||||
}
|
||||
|
||||
}
|
||||
-19
@@ -1,19 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -91,7 +91,6 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
glCapRedirects.put(org.lwjgl.opengl.GL12.GL_RESCALE_NORMAL, "RescaleNormal");
|
||||
glCapRedirects.put(org.lwjgl.opengl.GL11.GL_SCISSOR_TEST, "ScissorTest");
|
||||
methodRedirects.put(GL11, RedirectMap.newMap()
|
||||
.add("glGetFloat")
|
||||
.add("glAlphaFunc")
|
||||
.add("glBindTexture")
|
||||
.add("glBlendFunc")
|
||||
@@ -114,24 +113,35 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
.add("glFog")
|
||||
.add("glFogf")
|
||||
.add("glFogi")
|
||||
.add("glFrustum")
|
||||
.add("glGetBoolean")
|
||||
.add("glGetFloat")
|
||||
.add("glGetInteger")
|
||||
.add("glGetTexLevelParameteri")
|
||||
.add("glGetTexParameterf")
|
||||
.add("glGetTexParameteri")
|
||||
.add("glIsEnabled")
|
||||
.add("glLoadIdentity")
|
||||
.add("glMatrixMode")
|
||||
.add("glMultMatrix")
|
||||
.add("glNewList")
|
||||
.add("glPushAttrib")
|
||||
.add("glOrtho")
|
||||
.add("glPopAttrib")
|
||||
.add("glPopMatrix")
|
||||
.add("glPushAttrib")
|
||||
.add("glPushMatrix")
|
||||
.add("glRotated")
|
||||
.add("glRotatef")
|
||||
.add("glScaled")
|
||||
.add("glScalef")
|
||||
.add("glTexParameter")
|
||||
.add("glTexParameterf")
|
||||
.add("glTexParameteri")
|
||||
.add("glShadeModel")
|
||||
.add("glTexImage2D")
|
||||
.add("glMatrixMode")
|
||||
.add("glLoadIdentity")
|
||||
.add("glTranslatef")
|
||||
.add("glTexParameteri")
|
||||
.add("glTranslated")
|
||||
.add("glScalef")
|
||||
.add("glScaled")
|
||||
.add("glMultMatrix")
|
||||
.add("glRotatef")
|
||||
.add("glRotated")
|
||||
.add("glOrtho")
|
||||
.add("glFrustum")
|
||||
.add("glPushMatrix")
|
||||
.add("glPopMatrix")
|
||||
.add("glTranslatef")
|
||||
.add("glViewport")
|
||||
);
|
||||
methodRedirects.put(GL13, RedirectMap.newMap().add("glActiveTexture"));
|
||||
|
||||
@@ -2,6 +2,7 @@ package me.jellysquid.mods.sodium.client.gui;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import jss.notfine.core.Settings;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.ReeseSodiumVideoOptionsScreen;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.OptionFlag;
|
||||
@@ -412,6 +413,15 @@ public class SodiumGameOptionPages {
|
||||
.setBinding((opts, value) -> opts.performance.useNoErrorGLContext = value, opts -> opts.performance.useNoErrorGLContext)
|
||||
.setFlags(OptionFlag.REQUIRES_GAME_RESTART)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_gl_state_cache.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_gl_state_cache.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.EXTREME)
|
||||
.setBinding((opts, value) -> GLStateManager.BYPASS_CACHE = !value, opts -> !GLStateManager.BYPASS_CACHE)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
|
||||
.build());
|
||||
|
||||
return new OptionPage(I18n.format("sodium.options.pages.performance"), ImmutableList.copyOf(groups));
|
||||
|
||||
+2
-8
@@ -1,5 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.model.vertex.buffer;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat;
|
||||
import org.lwjgl.BufferUtils;
|
||||
|
||||
@@ -24,14 +25,7 @@ public class VertexBufferBuilder implements VertexBufferView {
|
||||
// The new capacity will at least as large as the write it needs to service
|
||||
final int cap = Math.max(this.capacity * 2, this.capacity + len);
|
||||
|
||||
// Allocate a new buffer and copy the old buffer's contents into it
|
||||
final ByteBuffer buffer = BufferUtils.createByteBuffer(cap);
|
||||
this.buffer.rewind();
|
||||
buffer.put(this.buffer);
|
||||
buffer.position(0);
|
||||
|
||||
// Update the buffer and capacity now
|
||||
this.buffer = buffer;
|
||||
this.buffer = CompatMemoryUtil.memReallocDirect(this.buffer, cap);
|
||||
this.capacity = cap;
|
||||
}
|
||||
|
||||
|
||||
@@ -3,16 +3,12 @@ package net.coderbot.iris;
|
||||
import com.google.common.base.Throwables;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.Tags;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.mitchej123.hodgepodge.Common;
|
||||
import com.mitchej123.hodgepodge.client.HodgepodgeClient;
|
||||
import com.mojang.realmsclient.gui.ChatFormatting;
|
||||
import cpw.mods.fml.client.registry.ClientRegistry;
|
||||
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.common.gameevent.InputEvent;
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.config.IrisConfig;
|
||||
import net.coderbot.iris.gl.GLDebug;
|
||||
import net.coderbot.iris.gl.shader.StandardMacros;
|
||||
import net.coderbot.iris.gui.screen.ShaderPackScreen;
|
||||
import net.coderbot.iris.pipeline.DeferredWorldRenderingPipeline;
|
||||
@@ -38,8 +34,6 @@ import net.minecraft.launchwrapper.Launch;
|
||||
import net.minecraft.util.ChatComponentText;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.opengl.ContextCapabilities;
|
||||
import org.lwjgl.opengl.GLContext;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
@@ -61,7 +55,6 @@ import java.util.zip.ZipException;
|
||||
|
||||
public class Iris {
|
||||
public final boolean isDevelopmentEnvironment;
|
||||
public static ContextCapabilities capabilities;
|
||||
|
||||
/**
|
||||
* The user-facing name of the mod. Moved into a constant to facilitate easy branding changes (for forks). You'll still need to change this separately in
|
||||
@@ -179,9 +172,6 @@ public class Iris {
|
||||
initialized = true;
|
||||
}
|
||||
|
||||
public static void identifyCapabilities() {
|
||||
capabilities = GLContext.getCapabilities();
|
||||
}
|
||||
/**
|
||||
* Called once RenderSystem#initRenderer has completed. This means that we can safely access OpenGL.
|
||||
*/
|
||||
@@ -192,8 +182,6 @@ public class Iris {
|
||||
return;
|
||||
}
|
||||
|
||||
setDebug(irisConfig.areDebugOptionsEnabled());
|
||||
|
||||
PBRTextureManager.INSTANCE.init();
|
||||
|
||||
// Only load the shader pack when we can access OpenGL
|
||||
@@ -387,34 +375,6 @@ public class Iris {
|
||||
logger.info("Shaders are disabled");
|
||||
}
|
||||
|
||||
// Temp escalation
|
||||
public static void setDebug(boolean enable) {
|
||||
GLStateManager.assertMainThread();
|
||||
final int success;
|
||||
if (enable) {
|
||||
success = GLDebug.setupDebugMessageCallback();
|
||||
} else {
|
||||
success = GLDebug.disableDebugMessages();
|
||||
}
|
||||
logger.info("Debug functionality is " + (enable ? "enabled, logging will be more verbose!" : "disabled."));
|
||||
if (Minecraft.getMinecraft().thePlayer != null) {
|
||||
Minecraft.getMinecraft().thePlayer.sendChatMessage(I18n.format(success != 0 ? (enable
|
||||
? "iris.shaders.debug.enabled"
|
||||
: "iris.shaders.debug.disabled") : "iris.shaders.debug.failure"));
|
||||
if (success == 2) {
|
||||
Minecraft.getMinecraft().thePlayer.sendChatMessage(I18n.format("iris.shaders.debug.restart"));
|
||||
}
|
||||
}
|
||||
if(Iris.isInitialized()) {
|
||||
try {
|
||||
irisConfig.setDebugEnabled(enable);
|
||||
irisConfig.save();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static Optional<Properties> tryReadConfigProperties(Path path) {
|
||||
final Properties properties = new Properties();
|
||||
|
||||
|
||||
@@ -27,11 +27,6 @@ public class IrisConfig {
|
||||
*/
|
||||
private boolean enableShaders;
|
||||
|
||||
/**
|
||||
* If debug features should be enabled. Gives much more detailed OpenGL error outputs at the cost of performance.
|
||||
*/
|
||||
private boolean enableDebugOptions;
|
||||
|
||||
/**
|
||||
* If the update notification should be disabled or not.
|
||||
*/
|
||||
@@ -42,7 +37,6 @@ public class IrisConfig {
|
||||
public IrisConfig(Path propertiesPath) {
|
||||
shaderPackName = null;
|
||||
enableShaders = true;
|
||||
enableDebugOptions = false;
|
||||
disableUpdateMessage = false;
|
||||
this.propertiesPath = propertiesPath;
|
||||
}
|
||||
@@ -97,18 +91,10 @@ public class IrisConfig {
|
||||
return enableShaders;
|
||||
}
|
||||
|
||||
public boolean areDebugOptionsEnabled() {
|
||||
return enableDebugOptions;
|
||||
}
|
||||
|
||||
public boolean shouldDisableUpdateMessage() {
|
||||
return disableUpdateMessage;
|
||||
}
|
||||
|
||||
public void setDebugEnabled(boolean enabled) {
|
||||
enableDebugOptions = enabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets whether shaders should be used for rendering.
|
||||
*/
|
||||
@@ -134,7 +120,6 @@ public class IrisConfig {
|
||||
}
|
||||
shaderPackName = properties.getProperty("shaderPack");
|
||||
enableShaders = !"false".equals(properties.getProperty("enableShaders"));
|
||||
enableDebugOptions = "true".equals(properties.getProperty("enableDebugOptions"));
|
||||
disableUpdateMessage = "true".equals(properties.getProperty("disableUpdateMessage"));
|
||||
// TODO: GUI
|
||||
// try {
|
||||
@@ -161,7 +146,6 @@ public class IrisConfig {
|
||||
final Properties properties = new Properties();
|
||||
properties.setProperty("shaderPack", getShaderPackName().orElse(""));
|
||||
properties.setProperty("enableShaders", enableShaders ? "true" : "false");
|
||||
properties.setProperty("enableDebugOptions", enableDebugOptions ? "true" : "false");
|
||||
properties.setProperty("disableUpdateMessage", disableUpdateMessage ? "true" : "false");
|
||||
// properties.setProperty("maxShadowRenderDistance", String.valueOf(IrisVideoSettings.shadowDistance));
|
||||
properties.setProperty("maxShadowRenderDistance", String.valueOf(32));
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.features;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.minecraft.client.resources.I18n;
|
||||
import org.apache.commons.lang3.text.WordUtils;
|
||||
|
||||
@@ -9,8 +9,8 @@ import java.util.function.BooleanSupplier;
|
||||
|
||||
public enum FeatureFlags {
|
||||
SEPARATE_HARDWARE_SAMPLERS(() -> true, () -> true),
|
||||
PER_BUFFER_BLENDING(() -> true, IrisRenderSystem::supportsBufferBlending),
|
||||
COMPUTE_SHADERS(() -> true, IrisRenderSystem::supportsCompute),
|
||||
PER_BUFFER_BLENDING(() -> true, RenderSystem::supportsBufferBlending),
|
||||
COMPUTE_SHADERS(() -> true, RenderSystem::supportsCompute),
|
||||
ENTITY_TRANSLUCENT(() -> true, () -> true),
|
||||
UNKNOWN(() -> false, () -> false);
|
||||
|
||||
|
||||
@@ -1,504 +0,0 @@
|
||||
package net.coderbot.iris.gl;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Vector3i;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.ARBDirectStateAccess;
|
||||
import org.lwjgl.opengl.EXTShaderImageLoadStore;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
import org.lwjgl.opengl.GL40;
|
||||
import org.lwjgl.opengl.GL42;
|
||||
import org.lwjgl.opengl.GL43;
|
||||
import org.lwjgl.opengl.GL45;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* This class is responsible for abstracting calls to OpenGL and asserting that calls are run on the render thread.
|
||||
*/
|
||||
public class IrisRenderSystem {
|
||||
private static DSAAccess dsaState;
|
||||
private static boolean hasMultibind;
|
||||
private static boolean supportsCompute;
|
||||
|
||||
public static void initRenderer() {
|
||||
try {
|
||||
if (Iris.capabilities.OpenGL45) {
|
||||
dsaState = new DSACore();
|
||||
Iris.logger.info("OpenGL 4.5 detected, enabling DSA.");
|
||||
}
|
||||
hasMultibind = Iris.capabilities.OpenGL45;
|
||||
|
||||
} catch (NoSuchFieldError ignored) {}
|
||||
try {
|
||||
if (dsaState == null && Iris.capabilities.GL_ARB_direct_state_access) {
|
||||
dsaState = new DSAARB();
|
||||
Iris.logger.info("ARB_direct_state_access detected, enabling DSA.");
|
||||
}
|
||||
} catch (NoSuchFieldError ignored) {}
|
||||
if (dsaState == null) {
|
||||
dsaState = new DSAUnsupported();
|
||||
}
|
||||
|
||||
try {
|
||||
hasMultibind |= Iris.capabilities.GL_ARB_multi_bind;
|
||||
} catch (NoSuchFieldError ignored) {}
|
||||
|
||||
supportsCompute = supportsCompute();
|
||||
}
|
||||
|
||||
public static void getIntegerv(int pname, IntBuffer params) {
|
||||
GL11.glGetInteger(pname, params);
|
||||
}
|
||||
|
||||
public static void getFloatv(int pname, FloatBuffer params) {
|
||||
GL11.glGetFloat(pname, params);
|
||||
}
|
||||
|
||||
public static void generateMipmaps(int texture, int mipmapTarget) {
|
||||
dsaState.generateMipmaps(texture, mipmapTarget);
|
||||
}
|
||||
|
||||
public static void bindAttributeLocation(int program, int index, CharSequence name) {
|
||||
GL20.glBindAttribLocation(program, index, name);
|
||||
}
|
||||
|
||||
public static void texImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GLStateManager.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void uniformMatrix4fv(int location, boolean transpose, FloatBuffer matrix) {
|
||||
GL20.glUniformMatrix4(location, transpose, matrix);
|
||||
}
|
||||
|
||||
public static void copyTexImage2D(int target, int level, int internalFormat, int x, int y, int width, int height, int border) {
|
||||
GL11.glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
|
||||
}
|
||||
|
||||
public static void uniform1f(int location, float v0) {
|
||||
GL20.glUniform1f(location, v0);
|
||||
}
|
||||
|
||||
public static void uniform1i(int location, int v0) {
|
||||
GL20.glUniform1i(location, v0);
|
||||
}
|
||||
|
||||
public static void uniform2f(int location, float v0, float v1) {
|
||||
GL20.glUniform2f(location, v0, v1);
|
||||
}
|
||||
|
||||
public static void uniform2i(int location, int v0, int v1) {
|
||||
GL20.glUniform2i(location, v0, v1);
|
||||
}
|
||||
|
||||
public static void uniform3f(int location, float v0, float v1, float v2) {
|
||||
GL20.glUniform3f(location, v0, v1, v2);
|
||||
}
|
||||
|
||||
public static void uniform4f(int location, float v0, float v1, float v2, float v3) {
|
||||
GL20.glUniform4f(location, v0, v1, v2, v3);
|
||||
}
|
||||
|
||||
public static void uniform4i(int location, int v0, int v1, int v2, int v3) {
|
||||
GL20.glUniform4i(location, v0, v1, v2, v3);
|
||||
}
|
||||
|
||||
public static int getAttribLocation(int programId, String name) {
|
||||
return GL20.glGetAttribLocation(programId, name);
|
||||
}
|
||||
|
||||
public static int getUniformLocation(int programId, String name) {
|
||||
return GL20.glGetUniformLocation(programId, name);
|
||||
}
|
||||
|
||||
public static void texParameteriv(int texture, int target, int pname, IntBuffer params) {
|
||||
dsaState.texParameteriv(texture, target, pname, params);
|
||||
}
|
||||
|
||||
public static void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
|
||||
dsaState.copyTexSubImage2D(destTexture, target, i, i1, i2, i3, i4, width, height);
|
||||
}
|
||||
|
||||
public static void texParameteri(int texture, int target, int pname, int param) {
|
||||
dsaState.texParameteri(texture, target, pname, param);
|
||||
}
|
||||
|
||||
public static void texParameterf(int texture, int target, int pname, float param) {
|
||||
dsaState.texParameterf(texture, target, pname, param);
|
||||
}
|
||||
|
||||
public static String getProgramInfoLog(int program) {
|
||||
return GL20.glGetProgramInfoLog(program, GL20.glGetProgrami(program, GL20.GL_INFO_LOG_LENGTH));
|
||||
}
|
||||
|
||||
public static String getShaderInfoLog(int shader) {
|
||||
return GL20.glGetShaderInfoLog(shader, GL20.glGetShaderi(shader, GL20.GL_INFO_LOG_LENGTH));
|
||||
}
|
||||
|
||||
public static void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
dsaState.drawBuffers(framebuffer, buffers);
|
||||
}
|
||||
|
||||
public static void readBuffer(int framebuffer, int buffer) {
|
||||
dsaState.readBuffer(framebuffer, buffer);
|
||||
}
|
||||
|
||||
public static String getActiveUniform(int program, int index, int maxLength, IntBuffer sizeType) {
|
||||
return GL20.glGetActiveUniform(program, index, maxLength, sizeType);
|
||||
}
|
||||
|
||||
public static void readPixels(int x, int y, int width, int height, int format, int type, FloatBuffer pixels) {
|
||||
GL11.glReadPixels(x, y, width, height, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void bufferData(int target, FloatBuffer data, int usage) {
|
||||
GL15.glBufferData(target, data, usage);
|
||||
}
|
||||
|
||||
public static int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
return dsaState.bufferStorage(target, data, usage);
|
||||
}
|
||||
|
||||
public static void vertexAttrib4f(int index, float v0, float v1, float v2, float v3) {
|
||||
GL20.glVertexAttrib4f(index, v0, v1, v2, v3);
|
||||
}
|
||||
|
||||
public static void detachShader(int program, int shader) {
|
||||
GL20.glDetachShader(program, shader);
|
||||
}
|
||||
|
||||
public static void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
dsaState.framebufferTexture2D(fb, fbtarget, attachment, target, texture, levels);
|
||||
}
|
||||
|
||||
public static int getTexParameteri(int texture, int target, int pname) {
|
||||
return dsaState.getTexParameteri(texture, target, pname);
|
||||
}
|
||||
|
||||
public static void bindImageTexture(int unit, int texture, int level, boolean layered, int layer, int access, int format) {
|
||||
if (Iris.capabilities.OpenGL42) {
|
||||
GL42.glBindImageTexture(unit, texture, level, layered, layer, access, format);
|
||||
} else {
|
||||
EXTShaderImageLoadStore.glBindImageTextureEXT(unit, texture, level, layered, layer, access, format);
|
||||
}
|
||||
}
|
||||
|
||||
public static int getMaxImageUnits() {
|
||||
if (Iris.capabilities.OpenGL42) {
|
||||
return GL11.glGetInteger(GL42.GL_MAX_IMAGE_UNITS);
|
||||
} else if (Iris.capabilities.GL_EXT_shader_image_load_store) {
|
||||
return GL11.glGetInteger(EXTShaderImageLoadStore.GL_MAX_IMAGE_UNITS_EXT);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
public static void getProgramiv(int program, int value, IntBuffer storage) {
|
||||
GL20.glGetProgram(program, value, storage);
|
||||
}
|
||||
|
||||
public static void dispatchCompute(int workX, int workY, int workZ) {
|
||||
GL43.glDispatchCompute(workX, workY, workZ);
|
||||
}
|
||||
|
||||
public static void dispatchCompute(Vector3i workGroups) {
|
||||
GL43.glDispatchCompute(workGroups.x, workGroups.y, workGroups.z);
|
||||
}
|
||||
|
||||
public static void memoryBarrier(int barriers) {
|
||||
if (supportsCompute) {
|
||||
GL42.glMemoryBarrier(barriers);
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean supportsBufferBlending() {
|
||||
return Iris.capabilities.GL_ARB_draw_buffers_blend || Iris.capabilities.OpenGL40;
|
||||
}
|
||||
|
||||
public static void disableBufferBlend(int buffer) {
|
||||
GL30.glDisablei(GL11.GL_BLEND, buffer);
|
||||
}
|
||||
|
||||
public static void enableBufferBlend(int buffer) {
|
||||
GL30.glEnablei(GL11.GL_BLEND, buffer);
|
||||
}
|
||||
|
||||
public static void blendFuncSeparatei(int buffer, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
|
||||
GL40.glBlendFuncSeparatei(buffer, srcRGB, dstRGB, srcAlpha, dstAlpha);
|
||||
}
|
||||
|
||||
public static void bindTextureToUnit(int unit, int texture) {
|
||||
dsaState.bindTextureToUnit(unit, texture);
|
||||
}
|
||||
|
||||
public static FloatBuffer PROJECTION_MATRIX_BUFFER = BufferUtils.createFloatBuffer(16);
|
||||
public static void setupProjectionMatrix(Matrix4f matrix) {
|
||||
GL11.glMatrixMode(GL11.GL_PROJECTION);
|
||||
GL11.glPushMatrix();
|
||||
matrix.get(0, PROJECTION_MATRIX_BUFFER);
|
||||
GL11.glLoadMatrix(PROJECTION_MATRIX_BUFFER);
|
||||
GL11.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
}
|
||||
|
||||
public static void restoreProjectionMatrix() {
|
||||
GL11.glMatrixMode(GL11.GL_PROJECTION);
|
||||
GL11.glPopMatrix();
|
||||
GL11.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
}
|
||||
|
||||
public static void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2, int bufferChoice, int filter) {
|
||||
dsaState.blitFramebuffer(source, dest, offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
public static int createFramebuffer() {
|
||||
return dsaState.createFramebuffer();
|
||||
}
|
||||
|
||||
public static int createTexture(int target) {
|
||||
return dsaState.createTexture(target);
|
||||
}
|
||||
|
||||
public interface DSAAccess {
|
||||
void generateMipmaps(int texture, int target);
|
||||
|
||||
void texParameteri(int texture, int target, int pname, int param);
|
||||
void texParameterf(int texture, int target, int pname, float param);
|
||||
void texParameteriv(int texture, int target, int pname, IntBuffer params);
|
||||
|
||||
void readBuffer(int framebuffer, int buffer);
|
||||
|
||||
void drawBuffers(int framebuffer, IntBuffer buffers);
|
||||
|
||||
int getTexParameteri(int texture, int target, int pname);
|
||||
|
||||
void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height);
|
||||
|
||||
void bindTextureToUnit(int unit, int texture);
|
||||
|
||||
int bufferStorage(int target, FloatBuffer data, int usage);
|
||||
|
||||
void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2, int bufferChoice, int filter);
|
||||
|
||||
void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels);
|
||||
|
||||
int createFramebuffer();
|
||||
int createTexture(int target);
|
||||
}
|
||||
|
||||
public static class DSACore extends DSAARB {
|
||||
|
||||
}
|
||||
|
||||
public static class DSAARB extends DSAUnsupported {
|
||||
|
||||
@Override
|
||||
public void generateMipmaps(int texture, int target) {
|
||||
ARBDirectStateAccess.glGenerateTextureMipmap(texture);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteri(int texture, int target, int pname, int param) {
|
||||
ARBDirectStateAccess.glTextureParameteri(texture, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameterf(int texture, int target, int pname, float param) {
|
||||
ARBDirectStateAccess.glTextureParameterf(texture, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteriv(int texture, int target, int pname, IntBuffer params) {
|
||||
ARBDirectStateAccess.glTextureParameter(texture, pname, params);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readBuffer(int framebuffer, int buffer) {
|
||||
ARBDirectStateAccess.glNamedFramebufferReadBuffer(framebuffer, buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
ARBDirectStateAccess.glNamedFramebufferDrawBuffers(framebuffer, buffers);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTexParameteri(int texture, int target, int pname) {
|
||||
return ARBDirectStateAccess.glGetTextureParameteri(texture, pname);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
|
||||
ARBDirectStateAccess.glCopyTextureSubImage2D(destTexture, i, i1, i2, i3, i4, width, height);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void bindTextureToUnit(int unit, int texture) {
|
||||
if (texture == 0) {
|
||||
super.bindTextureToUnit(unit, texture);
|
||||
} else {
|
||||
ARBDirectStateAccess.glBindTextureUnit(unit, texture);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
int buffer = GL45.glCreateBuffers();
|
||||
GL45.glNamedBufferData(buffer, data, usage);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2, int bufferChoice, int filter) {
|
||||
ARBDirectStateAccess.glBlitNamedFramebuffer(source, dest, offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
ARBDirectStateAccess.glNamedFramebufferTexture(fb, attachment, texture, levels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createFramebuffer() {
|
||||
return ARBDirectStateAccess.glCreateFramebuffers();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createTexture(int target) {
|
||||
return ARBDirectStateAccess.glCreateTextures(target);
|
||||
}
|
||||
}
|
||||
|
||||
public static class DSAUnsupported implements DSAAccess {
|
||||
@Override
|
||||
public void generateMipmaps(int texture, int target) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GL30.glGenerateMipmap(target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteri(int texture, int target, int pname, int param) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GL11.glTexParameteri(target, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameterf(int texture, int target, int pname, float param) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GL11.glTexParameterf(target, pname, param);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteriv(int texture, int target, int pname, IntBuffer params) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readBuffer(int framebuffer, int buffer) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GL11.glReadBuffer(buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GL20.glDrawBuffers(buffers);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTexParameteri(int texture, int target, int pname) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
return GL11.glGetTexParameteri(target, pname);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
|
||||
int previous = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, destTexture);
|
||||
GL11.glCopyTexSubImage2D(target, i, i1, i2, i3, i4, width, height);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, previous);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void bindTextureToUnit(int unit, int texture) {
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + unit);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
int buffer = GL15.glGenBuffers();
|
||||
GL15.glBindBuffer(target, buffer);
|
||||
bufferData(target, data, usage);
|
||||
GL15.glBindBuffer(target, 0);
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2, int bufferChoice, int filter) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_READ_FRAMEBUFFER, source);
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_DRAW_FRAMEBUFFER, dest);
|
||||
GL30.glBlitFramebuffer(offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(fbtarget, fb);
|
||||
GL30.glFramebufferTexture2D(fbtarget, attachment, target, texture, levels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createFramebuffer() {
|
||||
int framebuffer = OpenGlHelper.func_153165_e/*glGenFramebuffers*/();
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
return framebuffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createTexture(int target) {
|
||||
int texture = GL11.glGenTextures();
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
return texture;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
public static void bindTextures(int startingTexture, int[] bindings) {
|
||||
if (hasMultibind) {
|
||||
ARBMultiBind.glBindTextures(startingTexture, bindings);
|
||||
} else if (dsaState != DSAState.NONE) {
|
||||
for (int binding : bindings) {
|
||||
ARBDirectStateAccess.glBindTextureUnit(startingTexture, binding);
|
||||
startingTexture++;
|
||||
}
|
||||
} else {
|
||||
for (int binding : bindings) {
|
||||
GLStateManager.glActiveTexture(startingTexture);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, binding);
|
||||
startingTexture++;
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
// TODO: Proper notification of compute support
|
||||
public static boolean supportsCompute() {
|
||||
try {
|
||||
return Iris.capabilities.GL_ARB_compute_shader;
|
||||
} catch(Exception ignored) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package net.coderbot.iris.gl.blending;
|
||||
|
||||
public class BlendMode {
|
||||
private final int srcRgb;
|
||||
private final int dstRgb;
|
||||
private final int srcAlpha;
|
||||
private final int dstAlpha;
|
||||
|
||||
public BlendMode(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
this.srcRgb = srcRgb;
|
||||
this.dstRgb = dstRgb;
|
||||
this.srcAlpha = srcAlpha;
|
||||
this.dstAlpha = dstAlpha;
|
||||
}
|
||||
|
||||
public int getSrcRgb() {
|
||||
return srcRgb;
|
||||
}
|
||||
|
||||
public int getDstRgb() {
|
||||
return dstRgb;
|
||||
}
|
||||
|
||||
public int getSrcAlpha() {
|
||||
return srcAlpha;
|
||||
}
|
||||
|
||||
public int getDstAlpha() {
|
||||
return dstAlpha;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +1,13 @@
|
||||
package net.coderbot.iris.gl.blending;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
|
||||
public class BlendModeOverride {
|
||||
public static final BlendModeOverride OFF = new BlendModeOverride(null);
|
||||
|
||||
private final BlendMode blendMode;
|
||||
private final BlendState blendMode;
|
||||
|
||||
public BlendModeOverride(BlendMode blendMode) {
|
||||
public BlendModeOverride(BlendState blendMode) {
|
||||
this.blendMode = blendMode;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,23 +1,22 @@
|
||||
package net.coderbot.iris.gl.blending;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
import lombok.Getter;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL14;
|
||||
|
||||
public class BlendModeStorage {
|
||||
private static boolean originalBlendEnable;
|
||||
private static BlendMode originalBlend;
|
||||
private static boolean blendLocked;
|
||||
private static final BlendState originalBlend = new BlendState();
|
||||
@Getter private static boolean blendLocked;
|
||||
|
||||
public static boolean isBlendLocked() {
|
||||
return blendLocked;
|
||||
}
|
||||
|
||||
public static void overrideBlend(BlendMode override) {
|
||||
public static void overrideBlend(BlendState override) {
|
||||
if (!blendLocked) {
|
||||
// Only save the previous state if the blend mode wasn't already locked
|
||||
originalBlendEnable = GL11.glGetBoolean(GL11.GL_BLEND);
|
||||
originalBlend = new BlendMode(GL11.glGetInteger(GL14.GL_BLEND_SRC_RGB), GL11.glGetInteger(GL14.GL_BLEND_DST_RGB), GL11.glGetInteger(GL14.GL_BLEND_SRC_ALPHA), GL11.glGetInteger(GL14.GL_BLEND_DST_ALPHA));
|
||||
originalBlend.set(GLStateManager.getBlendState());
|
||||
}
|
||||
|
||||
blendLocked = false;
|
||||
@@ -33,18 +32,18 @@ public class BlendModeStorage {
|
||||
blendLocked = true;
|
||||
}
|
||||
|
||||
public static void overrideBufferBlend(int index, BlendMode override) {
|
||||
public static void overrideBufferBlend(int index, BlendState override) {
|
||||
if (!blendLocked) {
|
||||
// Only save the previous state if the blend mode wasn't already locked
|
||||
originalBlendEnable = GL11.glGetBoolean(GL11.GL_BLEND);
|
||||
originalBlend = new BlendMode(GL11.glGetInteger(GL14.GL_BLEND_SRC_RGB), GL11.glGetInteger(GL14.GL_BLEND_DST_RGB), GL11.glGetInteger(GL14.GL_BLEND_SRC_ALPHA), GL11.glGetInteger(GL14.GL_BLEND_DST_ALPHA));
|
||||
originalBlend.set(GLStateManager.getBlendState());
|
||||
}
|
||||
|
||||
if (override == null) {
|
||||
IrisRenderSystem.disableBufferBlend(index);
|
||||
RenderSystem.disableBufferBlend(index);
|
||||
} else {
|
||||
IrisRenderSystem.enableBufferBlend(index);
|
||||
IrisRenderSystem.blendFuncSeparatei(index, override.getSrcRgb(), override.getDstRgb(), override.getSrcAlpha(), override.getDstAlpha());
|
||||
RenderSystem.enableBufferBlend(index);
|
||||
RenderSystem.blendFuncSeparatei(index, override.getSrcRgb(), override.getDstRgb(), override.getSrcAlpha(), override.getDstAlpha());
|
||||
}
|
||||
|
||||
blendLocked = true;
|
||||
@@ -55,7 +54,10 @@ public class BlendModeStorage {
|
||||
}
|
||||
|
||||
public static void deferBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
originalBlend = new BlendMode(srcRgb, dstRgb, srcAlpha, dstAlpha);
|
||||
originalBlend.setSrcRgb(srcRgb);
|
||||
originalBlend.setDstRgb(dstRgb);
|
||||
originalBlend.setSrcAlpha(srcAlpha);
|
||||
originalBlend.setDstAlpha(dstAlpha);
|
||||
}
|
||||
|
||||
public static void restoreBlend() {
|
||||
@@ -66,11 +68,11 @@ public class BlendModeStorage {
|
||||
blendLocked = false;
|
||||
|
||||
if (originalBlendEnable) {
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GLStateManager.enableBlend();
|
||||
} else {
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GLStateManager.disableBlend();
|
||||
}
|
||||
|
||||
GL14.glBlendFuncSeparate(originalBlend.getSrcRgb(), originalBlend.getDstRgb(), originalBlend.getSrcAlpha(), originalBlend.getDstAlpha());
|
||||
GLStateManager.tryBlendFuncSeparate(originalBlend.getSrcRgb(), originalBlend.getDstRgb(), originalBlend.getSrcAlpha(), originalBlend.getDstAlpha());
|
||||
}
|
||||
}
|
||||
@@ -1,19 +1,15 @@
|
||||
package net.coderbot.iris.gl.blending;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
import lombok.Getter;
|
||||
|
||||
@Getter
|
||||
public class BufferBlendInformation {
|
||||
private final int index;
|
||||
private final BlendMode blendMode;
|
||||
private final BlendState blendMode;
|
||||
|
||||
public BufferBlendInformation(int index, BlendMode blendMode) {
|
||||
public BufferBlendInformation(int index, BlendState blendMode) {
|
||||
this.index = index;
|
||||
this.blendMode = blendMode;
|
||||
}
|
||||
|
||||
public BlendMode getBlendMode() {
|
||||
return blendMode;
|
||||
}
|
||||
|
||||
public int getIndex() {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,12 @@
|
||||
package net.coderbot.iris.gl.blending;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
|
||||
public class BufferBlendOverride {
|
||||
private final int drawBuffer;
|
||||
private final BlendMode blendMode;
|
||||
private final BlendState blendMode;
|
||||
|
||||
public BufferBlendOverride(int drawBuffer, BlendMode blendMode) {
|
||||
public BufferBlendOverride(int drawBuffer, BlendState blendMode) {
|
||||
this.drawBuffer = drawBuffer;
|
||||
this.blendMode = blendMode;
|
||||
}
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
package net.coderbot.iris.gl.framebuffer;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
|
||||
import it.unimi.dsi.fastutil.ints.Int2IntArrayMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2IntMap;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.texture.DepthBufferFormat;
|
||||
import net.coderbot.iris.texture.TextureInfoCache;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -21,7 +21,7 @@ public class GlFramebuffer extends GlResource {
|
||||
private boolean hasDepthAttachment;
|
||||
|
||||
public GlFramebuffer() {
|
||||
super(IrisRenderSystem.createFramebuffer());
|
||||
super(RenderSystem.createFramebuffer());
|
||||
|
||||
this.attachments = new Int2IntArrayMap();
|
||||
this.maxDrawBuffers = GL11.glGetInteger(GL20.GL_MAX_DRAW_BUFFERS);
|
||||
@@ -30,35 +30,35 @@ public class GlFramebuffer extends GlResource {
|
||||
}
|
||||
|
||||
public void addDepthAttachment(int texture) {
|
||||
int internalFormat = TextureInfoCache.INSTANCE.getInfo(texture).getInternalFormat();
|
||||
DepthBufferFormat depthBufferFormat = DepthBufferFormat.fromGlEnumOrDefault(internalFormat);
|
||||
final int internalFormat = TextureInfoCache.INSTANCE.getInfo(texture).getInternalFormat();
|
||||
final DepthBufferFormat depthBufferFormat = DepthBufferFormat.fromGlEnumOrDefault(internalFormat);
|
||||
|
||||
int fb = getGlId();
|
||||
final int fb = getGlId();
|
||||
|
||||
if (depthBufferFormat.isCombinedStencil()) {
|
||||
IrisRenderSystem.framebufferTexture2D(fb, GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_STENCIL_ATTACHMENT, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
RenderSystem.framebufferTexture2D(fb, GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_STENCIL_ATTACHMENT, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
} else {
|
||||
IrisRenderSystem.framebufferTexture2D(fb, GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
RenderSystem.framebufferTexture2D(fb, GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
}
|
||||
|
||||
this.hasDepthAttachment = true;
|
||||
}
|
||||
|
||||
public void addColorAttachment(int index, int texture) {
|
||||
int fb = getGlId();
|
||||
final int fb = getGlId();
|
||||
|
||||
IrisRenderSystem.framebufferTexture2D(fb, GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0 + index, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
RenderSystem.framebufferTexture2D(fb, GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0 + index, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
attachments.put(index, texture);
|
||||
}
|
||||
|
||||
public void noDrawBuffers() {
|
||||
IntBuffer buffer = BufferUtils.createIntBuffer(1);
|
||||
final IntBuffer buffer = BufferUtils.createIntBuffer(1);
|
||||
buffer.put(GL11.GL_NONE);
|
||||
IrisRenderSystem.drawBuffers(getGlId(), buffer);
|
||||
RenderSystem.drawBuffers(getGlId(), buffer);
|
||||
}
|
||||
|
||||
public void drawBuffers(int[] buffers) {
|
||||
IntBuffer glBuffers = BufferUtils.createIntBuffer(buffers.length);
|
||||
final IntBuffer glBuffers = BufferUtils.createIntBuffer(buffers.length);
|
||||
int index = 0;
|
||||
|
||||
if (buffers.length > maxDrawBuffers) {
|
||||
@@ -70,11 +70,11 @@ public class GlFramebuffer extends GlResource {
|
||||
}
|
||||
glBuffers.put(index++, GL30.GL_COLOR_ATTACHMENT0 + buffer);
|
||||
}
|
||||
IrisRenderSystem.drawBuffers(getGlId(), glBuffers);
|
||||
RenderSystem.drawBuffers(getGlId(), glBuffers);
|
||||
}
|
||||
|
||||
public void readBuffer(int buffer) {
|
||||
IrisRenderSystem.readBuffer(getGlId(), GL30.GL_COLOR_ATTACHMENT0 + buffer);
|
||||
RenderSystem.readBuffer(getGlId(), GL30.GL_COLOR_ATTACHMENT0 + buffer);
|
||||
}
|
||||
|
||||
public int getColorAttachment(int index) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.image;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
|
||||
import java.util.function.IntSupplier;
|
||||
@@ -19,6 +19,6 @@ public class ImageBinding {
|
||||
public void update() {
|
||||
// We can assume that image bindings are supported here as either the EXT extension or 4.2 core, as otherwise ImageLimits
|
||||
// would report that zero image units are supported.
|
||||
IrisRenderSystem.bindImageTexture(imageUnit, textureID.getAsInt(), 0, false, 0, GL15.GL_READ_WRITE, internalFormat);
|
||||
RenderSystem.bindImageTexture(imageUnit, textureID.getAsInt(), 0, false, 0, GL15.GL_READ_WRITE, internalFormat);
|
||||
}
|
||||
}
|
||||
@@ -1,13 +1,13 @@
|
||||
package net.coderbot.iris.gl.image;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
|
||||
public class ImageLimits {
|
||||
private final int maxImageUnits;
|
||||
private static ImageLimits instance;
|
||||
|
||||
private ImageLimits() {
|
||||
this.maxImageUnits = IrisRenderSystem.getMaxImageUnits();
|
||||
this.maxImageUnits = RenderSystem.getMaxImageUnits();
|
||||
}
|
||||
|
||||
public int getMaxImageUnits() {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.gl.program;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
|
||||
import org.joml.Vector2f;
|
||||
import org.joml.Vector3i;
|
||||
@@ -28,8 +28,7 @@ public final class ComputeProgram extends GlResource {
|
||||
super(program);
|
||||
|
||||
localSizeBuffer = BufferUtils.createIntBuffer(3);
|
||||
// localSize = new int[3];
|
||||
IrisRenderSystem.getProgramiv(program, GL43.GL_COMPUTE_WORK_GROUP_SIZE, localSizeBuffer);
|
||||
RenderSystem.getProgramiv(program, GL43.GL_COMPUTE_WORK_GROUP_SIZE, localSizeBuffer);
|
||||
this.uniforms = uniforms;
|
||||
this.samplers = samplers;
|
||||
this.images = images;
|
||||
@@ -65,10 +64,10 @@ public final class ComputeProgram extends GlResource {
|
||||
images.update();
|
||||
|
||||
if (!Iris.getPipelineManager().getPipeline().map(WorldRenderingPipeline::allowConcurrentCompute).orElse(false)) {
|
||||
IrisRenderSystem.memoryBarrier(40);
|
||||
RenderSystem.memoryBarrier(40);
|
||||
}
|
||||
|
||||
IrisRenderSystem.dispatchCompute(getWorkGroups(width, height));
|
||||
RenderSystem.dispatchCompute(getWorkGroups(width, height));
|
||||
}
|
||||
|
||||
public static void unbind() {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package net.coderbot.iris.gl.program;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.image.ImageHolder;
|
||||
import net.coderbot.iris.gl.sampler.SamplerHolder;
|
||||
import net.coderbot.iris.gl.shader.GlShader;
|
||||
@@ -27,7 +27,7 @@ public class ProgramBuilder extends ProgramUniforms.Builder implements SamplerHo
|
||||
}
|
||||
|
||||
public void bindAttributeLocation(int index, String name) {
|
||||
IrisRenderSystem.bindAttributeLocation(program, index, name);
|
||||
RenderSystem.bindAttributeLocation(program, index, name);
|
||||
}
|
||||
|
||||
public static ProgramBuilder begin(String name, @Nullable String vertexSource, @Nullable String geometrySource,
|
||||
@@ -66,7 +66,7 @@ public class ProgramBuilder extends ProgramUniforms.Builder implements SamplerHo
|
||||
}
|
||||
|
||||
public static ProgramBuilder beginCompute(String name, @Nullable String source, ImmutableSet<Integer> reservedTextureUnits) {
|
||||
if (!IrisRenderSystem.supportsCompute()) {
|
||||
if (!RenderSystem.supportsCompute()) {
|
||||
throw new IllegalStateException("This PC does not support compute shaders, but it's attempting to be used???");
|
||||
}
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package net.coderbot.iris.gl.program;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.image.ImageBinding;
|
||||
import net.coderbot.iris.gl.image.ImageHolder;
|
||||
import net.coderbot.iris.gl.image.ImageLimits;
|
||||
@@ -24,7 +24,7 @@ public class ProgramImages {
|
||||
public void update() {
|
||||
if (initializer != null) {
|
||||
for (GlUniform1iCall call : initializer) {
|
||||
IrisRenderSystem.uniform1i(call.getLocation(), call.getValue());
|
||||
RenderSystem.uniform1i(call.getLocation(), call.getValue());
|
||||
}
|
||||
|
||||
initializer = null;
|
||||
|
||||
@@ -3,8 +3,8 @@ package net.coderbot.iris.gl.program;
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.sampler.SamplerBinding;
|
||||
import net.coderbot.iris.gl.sampler.SamplerHolder;
|
||||
import net.coderbot.iris.gl.sampler.SamplerLimits;
|
||||
@@ -38,7 +38,7 @@ public class ProgramSamplers {
|
||||
|
||||
if (initializer != null) {
|
||||
for (GlUniform1iCall call : initializer) {
|
||||
IrisRenderSystem.uniform1i(call.getLocation(), call.getValue());
|
||||
RenderSystem.uniform1i(call.getLocation(), call.getValue());
|
||||
}
|
||||
|
||||
initializer = null;
|
||||
@@ -126,7 +126,7 @@ public class ProgramSamplers {
|
||||
}
|
||||
|
||||
for (String name : names) {
|
||||
int location = IrisRenderSystem.getUniformLocation(program, name);
|
||||
int location = RenderSystem.getUniformLocation(program, name);
|
||||
|
||||
if (location == -1) {
|
||||
// There's no active sampler with this particular name in the program.
|
||||
@@ -141,7 +141,7 @@ public class ProgramSamplers {
|
||||
|
||||
@Override
|
||||
public boolean hasSampler(String name) {
|
||||
return IrisRenderSystem.getUniformLocation(program, name) != -1;
|
||||
return RenderSystem.getUniformLocation(program, name) != -1;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -175,7 +175,7 @@ public class ProgramSamplers {
|
||||
|
||||
private boolean addDynamicSampler(IntSupplier sampler, boolean used, ValueUpdateNotifier notifier, String... names) {
|
||||
for (String name : names) {
|
||||
int location = IrisRenderSystem.getUniformLocation(program, name);
|
||||
int location = RenderSystem.getUniformLocation(program, name);
|
||||
|
||||
if (location == -1) {
|
||||
// There's no active sampler with this particular name in the program.
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.gl.program;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
import net.coderbot.iris.gl.uniform.DynamicLocationalUniformHolder;
|
||||
import net.coderbot.iris.gl.uniform.Uniform;
|
||||
@@ -165,7 +165,7 @@ public class ProgramUniforms {
|
||||
|
||||
@Override
|
||||
public OptionalInt location(String name, UniformType type) {
|
||||
int id = IrisRenderSystem.getUniformLocation(program, name);
|
||||
int id = RenderSystem.getUniformLocation(program, name);
|
||||
|
||||
if (id == -1) {
|
||||
return OptionalInt.empty();
|
||||
@@ -190,7 +190,7 @@ public class ProgramUniforms {
|
||||
IntBuffer sizeType = BufferUtils.createIntBuffer(2);
|
||||
|
||||
for (int index = 0; index < activeUniforms; index++) {
|
||||
final String name = IrisRenderSystem.getActiveUniform(program, index, 128, sizeType);
|
||||
final String name = RenderSystem.getActiveUniform(program, index, 128, sizeType);
|
||||
|
||||
if (name.isEmpty()) {
|
||||
// No further information available.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.sampler;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
|
||||
import java.util.function.IntSupplier;
|
||||
@@ -25,6 +25,6 @@ public class SamplerBinding {
|
||||
}
|
||||
|
||||
private void updateSampler() {
|
||||
IrisRenderSystem.bindTextureToUnit(textureUnit, texture.getAsInt());
|
||||
RenderSystem.bindTextureToUnit(textureUnit, texture.getAsInt());
|
||||
}
|
||||
}
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
package net.coderbot.iris.gl.shader;
|
||||
|
||||
import net.coderbot.iris.gl.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -37,7 +37,7 @@ public class GlShader extends GlResource {
|
||||
|
||||
GLDebug.nameObject(KHRDebug.GL_SHADER, handle, name + "(" + type.name().toLowerCase(Locale.ROOT) + ")");
|
||||
|
||||
String log = IrisRenderSystem.getShaderInfoLog(handle);
|
||||
String log = RenderSystem.getShaderInfoLog(handle);
|
||||
|
||||
if (!log.isEmpty()) {
|
||||
LOGGER.warn("Shader compilation log for " + name + ": " + log);
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
|
||||
package net.coderbot.iris.gl.shader;
|
||||
|
||||
import net.coderbot.iris.gl.GLDebug;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -17,10 +17,10 @@ public class ProgramCreator {
|
||||
int program = GL20.glCreateProgram();
|
||||
|
||||
// TODO: This is *really* hardcoded, we need to refactor this to support external calls to glBindAttribLocation
|
||||
IrisRenderSystem.bindAttributeLocation(program, 11, "mc_Entity");
|
||||
IrisRenderSystem.bindAttributeLocation(program, 12, "mc_midTexCoord");
|
||||
IrisRenderSystem.bindAttributeLocation(program, 13, "at_tangent");
|
||||
IrisRenderSystem.bindAttributeLocation(program, 14, "at_midBlock");
|
||||
RenderSystem.bindAttributeLocation(program, 11, "mc_Entity");
|
||||
RenderSystem.bindAttributeLocation(program, 12, "mc_midTexCoord");
|
||||
RenderSystem.bindAttributeLocation(program, 13, "at_tangent");
|
||||
RenderSystem.bindAttributeLocation(program, 14, "at_midBlock");
|
||||
|
||||
for (GlShader shader : shaders) {
|
||||
GL20.glAttachShader(program, shader.getHandle());
|
||||
@@ -32,10 +32,10 @@ public class ProgramCreator {
|
||||
|
||||
//Always detach shaders according to https://www.khronos.org/opengl/wiki/Shader_Compilation#Cleanup
|
||||
for (GlShader shader : shaders) {
|
||||
IrisRenderSystem.detachShader(program, shader.getHandle());
|
||||
RenderSystem.detachShader(program, shader.getHandle());
|
||||
}
|
||||
|
||||
String log = IrisRenderSystem.getProgramInfoLog(program);
|
||||
String log = RenderSystem.getProgramInfoLog(program);
|
||||
|
||||
if (!log.isEmpty()) {
|
||||
LOGGER.warn("Program link log for " + name + ": " + log);
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package net.coderbot.iris.gl.texture;
|
||||
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL43;
|
||||
@@ -22,7 +22,7 @@ public interface DepthCopyStrategy {
|
||||
public void copy(GlFramebuffer sourceFb, int sourceTexture, GlFramebuffer destFb, int destTexture, int width, int height) {
|
||||
sourceFb.bindAsReadBuffer();
|
||||
|
||||
IrisRenderSystem.copyTexSubImage2D(
|
||||
RenderSystem.copyTexSubImage2D(
|
||||
destTexture,
|
||||
// target
|
||||
GL11.GL_TEXTURE_2D,
|
||||
@@ -52,7 +52,7 @@ public interface DepthCopyStrategy {
|
||||
|
||||
@Override
|
||||
public void copy(GlFramebuffer sourceFb, int sourceTexture, GlFramebuffer destFb, int destTexture, int width, int height) {
|
||||
IrisRenderSystem.blitFramebuffer(sourceFb.getId(), destFb.getId(), 0, 0, width, height,
|
||||
RenderSystem.blitFramebuffer(sourceFb.getId(), destFb.getId(), 0, 0, width, height,
|
||||
0, 0, width, height,
|
||||
GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_STENCIL_BUFFER_BIT,
|
||||
GL11.GL_NEAREST);
|
||||
@@ -78,7 +78,7 @@ public interface DepthCopyStrategy {
|
||||
}
|
||||
|
||||
static DepthCopyStrategy fastest(boolean combinedStencilRequired) {
|
||||
if (Iris.capabilities.GL_ARB_copy_image) {
|
||||
if (GLStateManager.capabilities.GL_ARB_copy_image) {
|
||||
return new Gl43CopyImage();
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
|
||||
public class FloatUniform extends Uniform {
|
||||
@@ -32,7 +32,7 @@ public class FloatUniform extends Uniform {
|
||||
|
||||
if (cachedValue != newValue) {
|
||||
cachedValue = newValue;
|
||||
IrisRenderSystem.uniform1f(location, newValue);
|
||||
RenderSystem.uniform1f(location, newValue);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
|
||||
import java.util.function.IntSupplier;
|
||||
@@ -34,7 +34,7 @@ public class IntUniform extends Uniform {
|
||||
|
||||
if (cachedValue != newValue) {
|
||||
cachedValue = newValue;
|
||||
IrisRenderSystem.uniform1i(location, newValue);
|
||||
RenderSystem.uniform1i(location, newValue);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.lwjgl.BufferUtils;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
@@ -29,7 +29,7 @@ public class MatrixFromFloatArrayUniform extends Uniform {
|
||||
buffer.put(cachedValue);
|
||||
buffer.rewind();
|
||||
|
||||
IrisRenderSystem.uniformMatrix4fv(location, false, buffer);
|
||||
RenderSystem.uniformMatrix4fv(location, false, buffer);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
|
||||
@@ -31,7 +31,7 @@ public class MatrixUniform extends Uniform {
|
||||
cachedValue.get(buffer);
|
||||
buffer.rewind();
|
||||
|
||||
IrisRenderSystem.uniformMatrix4fv(location, false, buffer);
|
||||
RenderSystem.uniformMatrix4fv(location, false, buffer);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.minecraft.util.Vec3;
|
||||
|
||||
import java.util.function.Supplier;
|
||||
@@ -24,7 +24,7 @@ public class VanillaVector3Uniform extends Uniform {
|
||||
cachedValue.xCoord = newValue.xCoord;
|
||||
cachedValue.yCoord = newValue.yCoord;
|
||||
cachedValue.zCoord = newValue.zCoord;
|
||||
IrisRenderSystem.uniform3f(location, (float)cachedValue.xCoord, (float)cachedValue.yCoord, (float)cachedValue.zCoord);
|
||||
RenderSystem.uniform3f(location, (float)cachedValue.xCoord, (float)cachedValue.yCoord, (float)cachedValue.zCoord);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
import org.joml.Vector2i;
|
||||
|
||||
@@ -35,7 +35,7 @@ public class Vector2IntegerJomlUniform extends Uniform {
|
||||
|
||||
if (cachedValue == null || !newValue.equals(cachedValue)) {
|
||||
cachedValue = newValue;
|
||||
IrisRenderSystem.uniform2i(this.location, newValue.x, newValue.y);
|
||||
RenderSystem.uniform2i(this.location, newValue.x, newValue.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.joml.Vector2f;
|
||||
|
||||
import java.util.function.Supplier;
|
||||
@@ -23,7 +23,7 @@ public class Vector2Uniform extends Uniform {
|
||||
|
||||
if (cachedValue == null || !newValue.equals(cachedValue)) {
|
||||
cachedValue = newValue;
|
||||
IrisRenderSystem.uniform2f(this.location, newValue.x, newValue.y);
|
||||
RenderSystem.uniform2f(this.location, newValue.x, newValue.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.joml.Vector3d;
|
||||
import org.joml.Vector3f;
|
||||
import org.joml.Vector4f;
|
||||
@@ -48,7 +48,7 @@ public class Vector3Uniform extends Uniform {
|
||||
|
||||
if (!newValue.equals(cachedValue)) {
|
||||
cachedValue.set(newValue.x(), newValue.y(), newValue.z());
|
||||
IrisRenderSystem.uniform3f(location, cachedValue.x(), cachedValue.y(), cachedValue.z());
|
||||
RenderSystem.uniform3f(location, cachedValue.x(), cachedValue.y(), cachedValue.z());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
import org.joml.Vector4i;
|
||||
|
||||
@@ -35,7 +35,7 @@ public class Vector4IntegerJomlUniform extends Uniform {
|
||||
|
||||
if (cachedValue == null || !newValue.equals(cachedValue)) {
|
||||
cachedValue = newValue;
|
||||
IrisRenderSystem.uniform4i(this.location, newValue.x, newValue.y, newValue.z, newValue.w);
|
||||
RenderSystem.uniform4i(this.location, newValue.x, newValue.y, newValue.z, newValue.w);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.gl.uniform;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.state.ValueUpdateNotifier;
|
||||
import org.joml.Vector4f;
|
||||
|
||||
@@ -35,7 +35,7 @@ public class Vector4Uniform extends Uniform {
|
||||
|
||||
if (!newValue.equals(cachedValue)) {
|
||||
cachedValue.set(newValue.x(), newValue.y(), newValue.z(), newValue.w());
|
||||
IrisRenderSystem.uniform4f(location, cachedValue.x(), cachedValue.y(), cachedValue.z(), cachedValue.w());
|
||||
RenderSystem.uniform4f(location, cachedValue.x(), cachedValue.y(), cachedValue.z(), cachedValue.w());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import com.google.common.collect.ImmutableSet;
|
||||
import com.google.common.primitives.Ints;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Camera;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderingState;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.block_rendering.BlockMaterialMapping;
|
||||
@@ -49,7 +50,6 @@ import net.coderbot.iris.shaderpack.ProgramSource;
|
||||
import net.coderbot.iris.shaderpack.loading.ProgramId;
|
||||
import net.coderbot.iris.shaderpack.texture.TextureStage;
|
||||
import net.coderbot.iris.shadows.ShadowRenderTargets;
|
||||
import net.coderbot.iris.texture.TextureInfoCache;
|
||||
import net.coderbot.iris.texture.format.TextureFormat;
|
||||
import net.coderbot.iris.texture.format.TextureFormatLoader;
|
||||
import net.coderbot.iris.texture.pbr.PBRTextureHolder;
|
||||
@@ -1231,11 +1231,11 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
|
||||
@Override
|
||||
public void onBindTexture(int id) {
|
||||
if (shouldBindPBR && isRenderingWorld) {
|
||||
PBRTextureHolder pbrHolder = PBRTextureManager.INSTANCE.getOrLoadHolder(id);
|
||||
final PBRTextureHolder pbrHolder = PBRTextureManager.INSTANCE.getOrLoadHolder(id);
|
||||
currentNormalTexture = pbrHolder.getNormalTexture().getGlTextureId();
|
||||
currentSpecularTexture = pbrHolder.getSpecularTexture().getGlTextureId();
|
||||
|
||||
TextureFormat textureFormat = TextureFormatLoader.getFormat();
|
||||
final TextureFormat textureFormat = TextureFormatLoader.getFormat();
|
||||
if (textureFormat != null) {
|
||||
textureFormat.setupTextureParameters(PBRType.NORMAL, pbrHolder.getNormalTexture());
|
||||
textureFormat.setupTextureParameters(PBRType.SPECULAR, pbrHolder.getSpecularTexture());
|
||||
|
||||
@@ -10,6 +10,8 @@ import net.minecraft.entity.EntityLiving;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemBlock;
|
||||
import net.minecraft.item.ItemStack;
|
||||
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
public class HandRenderer {
|
||||
@@ -58,7 +60,11 @@ public class HandRenderer {
|
||||
public boolean isHandTranslucent(InteractionHand hand) {
|
||||
// TODO: Offhand
|
||||
// Item item = Minecraft.getMinecraft().thePlayer.getItemBySlot(hand == InteractionHand.OFF_HAND ? EquipmentSlot.OFFHAND : EquipmentSlot.MAINHAND).getItem();
|
||||
Item item = Minecraft.getMinecraft().thePlayer.getHeldItem().getItem();
|
||||
ItemStack heldItem = Minecraft.getMinecraft().thePlayer.getHeldItem();
|
||||
if (heldItem == null) {
|
||||
return false;
|
||||
}
|
||||
Item item = heldItem.getItem();
|
||||
|
||||
if (item instanceof ItemBlock itemBlock) {
|
||||
// TODO: RenderType
|
||||
|
||||
@@ -4,10 +4,10 @@ import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Camera;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderingState;
|
||||
import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.shaderpack.OptionalBoolean;
|
||||
import net.coderbot.iris.shaderpack.PackDirectives;
|
||||
import net.coderbot.iris.shaderpack.PackShadowDirectives;
|
||||
@@ -205,7 +205,7 @@ public class ShadowRenderer {
|
||||
private void configureDepthSampler(int glTextureId, PackShadowDirectives.DepthSamplingSettings settings) {
|
||||
if (settings.getHardwareFiltering()) {
|
||||
// We have to do this or else shadow hardware filtering breaks entirely!
|
||||
IrisRenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL14.GL_TEXTURE_COMPARE_MODE, GL30.GL_COMPARE_REF_TO_TEXTURE);
|
||||
RenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL14.GL_TEXTURE_COMPARE_MODE, GL30.GL_COMPARE_REF_TO_TEXTURE);
|
||||
}
|
||||
|
||||
// Workaround for issues with old shader packs like Chocapic v4.
|
||||
@@ -213,7 +213,7 @@ public class ShadowRenderer {
|
||||
// be available in r. So we set up the swizzle to fix that.
|
||||
swizzleBuf.rewind();
|
||||
swizzleBuf.put(new int[] { GL11.GL_RED, GL11.GL_RED, GL11.GL_RED, GL11.GL_ONE }).rewind();
|
||||
IrisRenderSystem.texParameteriv(glTextureId, GL11.GL_TEXTURE_2D, ARBTextureSwizzle.GL_TEXTURE_SWIZZLE_RGBA, swizzleBuf);
|
||||
RenderSystem.texParameteriv(glTextureId, GL11.GL_TEXTURE_2D, ARBTextureSwizzle.GL_TEXTURE_SWIZZLE_RGBA, swizzleBuf);
|
||||
|
||||
configureSampler(glTextureId, settings);
|
||||
}
|
||||
@@ -226,11 +226,11 @@ public class ShadowRenderer {
|
||||
|
||||
if (!settings.getNearest()) {
|
||||
// Make sure that things are smoothed
|
||||
IrisRenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
} else {
|
||||
IrisRenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
|
||||
IrisRenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(glTextureId, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -245,8 +245,8 @@ public class ShadowRenderer {
|
||||
}
|
||||
|
||||
private void setupMipmappingForTexture(int texture, int filteringMode) {
|
||||
IrisRenderSystem.generateMipmaps(texture, GL11.GL_TEXTURE_2D);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filteringMode);
|
||||
RenderSystem.generateMipmaps(texture, GL11.GL_TEXTURE_2D);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filteringMode);
|
||||
}
|
||||
|
||||
private FrustumHolder createShadowFrustum(float renderMultiplier, FrustumHolder holder) {
|
||||
@@ -322,7 +322,7 @@ public class ShadowRenderer {
|
||||
|
||||
private void setupGlState(Matrix4f projMatrix) {
|
||||
// Set up our projection matrix and load it into the legacy matrix stack
|
||||
IrisRenderSystem.setupProjectionMatrix(projMatrix);
|
||||
RenderSystem.setupProjectionMatrix(projMatrix);
|
||||
|
||||
// Disable backface culling
|
||||
// This partially works around an issue where if the front face of a mountain isn't visible, it casts no
|
||||
@@ -339,7 +339,7 @@ public class ShadowRenderer {
|
||||
GLStateManager.enableCull();
|
||||
|
||||
// Make sure to unload the projection matrix
|
||||
IrisRenderSystem.restoreProjectionMatrix();
|
||||
RenderSystem.restoreProjectionMatrix();
|
||||
}
|
||||
|
||||
private void copyPreTranslucentDepth() {
|
||||
|
||||
@@ -2,8 +2,7 @@ package net.coderbot.iris.postprocess;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
||||
import net.coderbot.iris.gl.program.Program;
|
||||
import net.coderbot.iris.gl.program.ProgramBuilder;
|
||||
@@ -40,7 +39,7 @@ public class CenterDepthSampler {
|
||||
this.framebuffer = new GlFramebuffer();
|
||||
|
||||
// Fall back to a less precise format if the system doesn't support OpenGL 3
|
||||
InternalTextureFormat format = Iris.capabilities.OpenGL32 ? InternalTextureFormat.R32F : InternalTextureFormat.RGB16;
|
||||
InternalTextureFormat format = GLStateManager.capabilities.OpenGL32 ? InternalTextureFormat.R32F : InternalTextureFormat.RGB16;
|
||||
setupColorTexture(texture, format);
|
||||
setupColorTexture(altTexture, format);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
@@ -51,7 +50,7 @@ public class CenterDepthSampler {
|
||||
try {
|
||||
String fsh = new String(IOUtils.toByteArray(Objects.requireNonNull(getClass().getResourceAsStream("/centerDepth.fsh"))), StandardCharsets.UTF_8);
|
||||
|
||||
if (Iris.capabilities.OpenGL32) {
|
||||
if (GLStateManager.capabilities.OpenGL32) {
|
||||
fsh = fsh.replace("VERSIONPLACEHOLDER", "150 compatibility");
|
||||
} else {
|
||||
fsh = fsh.replace("#define IS_GL3", "");
|
||||
@@ -98,12 +97,12 @@ public class CenterDepthSampler {
|
||||
}
|
||||
|
||||
public void setupColorTexture(int texture, InternalTextureFormat format) {
|
||||
IrisRenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, format.getGlFormat(), 1, 1, 0, format.getPixelFormat().getGlFormat(), PixelType.FLOAT.getGlFormat(), null);
|
||||
RenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, format.getGlFormat(), 1, 1, 0, format.getPixelFormat().getGlFormat(), PixelType.FLOAT.getGlFormat(), null);
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
}
|
||||
|
||||
public int getCenterDepthTexture() {
|
||||
|
||||
@@ -4,9 +4,9 @@ import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
||||
import net.coderbot.iris.gl.program.ComputeProgram;
|
||||
import net.coderbot.iris.gl.program.Program;
|
||||
@@ -218,7 +218,7 @@ public class CompositeRenderer {
|
||||
}
|
||||
|
||||
if (ranCompute) {
|
||||
IrisRenderSystem.memoryBarrier(40);
|
||||
RenderSystem.memoryBarrier(40);
|
||||
}
|
||||
|
||||
Program.unbind();
|
||||
@@ -279,14 +279,14 @@ public class CompositeRenderer {
|
||||
//
|
||||
// Also note that this only applies to one of the two buffers in a render target buffer pair - making it
|
||||
// unlikely that this issue occurs in practice with most shader packs.
|
||||
IrisRenderSystem.generateMipmaps(texture, GL11.GL_TEXTURE_2D);
|
||||
RenderSystem.generateMipmaps(texture, GL11.GL_TEXTURE_2D);
|
||||
|
||||
int filter = GL11.GL_LINEAR_MIPMAP_LINEAR;
|
||||
if (target.getInternalFormat().getPixelFormat().isInteger()) {
|
||||
filter = GL11.GL_NEAREST_MIPMAP_NEAREST;
|
||||
}
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
}
|
||||
|
||||
// TODO: Don't just copy this from DeferredWorldRenderingPipeline
|
||||
|
||||
@@ -3,9 +3,9 @@ package net.coderbot.iris.postprocess;
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import it.unimi.dsi.fastutil.ints.IntList;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
||||
import net.coderbot.iris.gl.program.ComputeProgram;
|
||||
import net.coderbot.iris.gl.program.Program;
|
||||
@@ -189,7 +189,7 @@ public class FinalPassRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
IrisRenderSystem.memoryBarrier(40);
|
||||
RenderSystem.memoryBarrier(40);
|
||||
|
||||
if (!finalPass.mipmappedBuffers.isEmpty()) {
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
@@ -216,7 +216,7 @@ public class FinalPassRenderer {
|
||||
// https://stackoverflow.com/a/23994979/18166885
|
||||
this.baseline.bindAsReadBuffer();
|
||||
|
||||
IrisRenderSystem.copyTexSubImage2D(main.framebufferTexture, GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, baseWidth, baseHeight);
|
||||
RenderSystem.copyTexSubImage2D(main.framebufferTexture, GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, baseWidth, baseHeight);
|
||||
}
|
||||
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
@@ -283,14 +283,14 @@ public class FinalPassRenderer {
|
||||
//
|
||||
// Also note that this only applies to one of the two buffers in a render target buffer pair - making it
|
||||
// unlikely that this issue occurs in practice with most shader packs.
|
||||
IrisRenderSystem.generateMipmaps(texture, GL11.GL_TEXTURE_2D);
|
||||
RenderSystem.generateMipmaps(texture, GL11.GL_TEXTURE_2D);
|
||||
|
||||
int filter = GL11.GL_LINEAR_MIPMAP_LINEAR;
|
||||
if (target.getInternalFormat().getPixelFormat().isInteger()) {
|
||||
filter = GL11.GL_NEAREST_MIPMAP_NEAREST;
|
||||
}
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
}
|
||||
|
||||
private static void resetRenderTarget(RenderTarget target) {
|
||||
@@ -301,8 +301,8 @@ public class FinalPassRenderer {
|
||||
filter = GL11.GL_NEAREST;
|
||||
}
|
||||
|
||||
IrisRenderSystem.texParameteri(target.getMainTexture(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
IrisRenderSystem.texParameteri(target.getAltTexture(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
RenderSystem.texParameteri(target.getMainTexture(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
RenderSystem.texParameteri(target.getAltTexture(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter);
|
||||
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.postprocess;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
@@ -82,6 +82,6 @@ public class FullScreenQuadRenderer {
|
||||
// Vertex 3: Bottom left corner
|
||||
0.0F, 0.0F, 0.0F, 0.0F, 0.0F }).rewind();
|
||||
|
||||
return IrisRenderSystem.bufferStorage(GL15.GL_ARRAY_BUFFER, vertices, GL15.GL_STATIC_DRAW);
|
||||
return RenderSystem.bufferStorage(GL15.GL_ARRAY_BUFFER, vertices, GL15.GL_STATIC_DRAW);
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.texture.TextureUploadHelper;
|
||||
import org.lwjgl.opengl.EXTFramebufferObject;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -12,16 +12,16 @@ import java.nio.ByteBuffer;
|
||||
|
||||
public class ColorTexture extends GlResource {
|
||||
public ColorTexture(int width, int height) {
|
||||
super(IrisRenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
super(RenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
final int texture = getGlId();
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
|
||||
TextureUploadHelper.resetTextureUploadState();
|
||||
IrisRenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL11.GL_RGBA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (ByteBuffer) null);
|
||||
RenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL11.GL_RGBA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (ByteBuffer) null);
|
||||
|
||||
EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT, EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT, GL11.GL_TEXTURE_2D, texture, 0);
|
||||
}
|
||||
|
||||
@@ -1,29 +1,29 @@
|
||||
package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.texture.DepthBufferFormat;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
|
||||
public class DepthTexture extends GlResource {
|
||||
public DepthTexture(int width, int height, DepthBufferFormat format) {
|
||||
super(IrisRenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
super(RenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
final int texture = getGlId();
|
||||
|
||||
resize(width, height, format);
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
void resize(int width, int height, DepthBufferFormat format) {
|
||||
IrisRenderSystem.texImage2D(getTextureId(), GL11.GL_TEXTURE_2D, 0, format.getGlInternalFormat(), width, height, 0,
|
||||
RenderSystem.texImage2D(getTextureId(), GL11.GL_TEXTURE_2D, 0, format.getGlInternalFormat(), width, height, 0,
|
||||
format.getGlType(), format.getGlFormat(), null);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.NativeImage;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.shaderpack.texture.CustomTextureData;
|
||||
import net.minecraft.client.renderer.texture.DynamicTexture;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -17,13 +17,13 @@ public class NativeImageBackedCustomTexture extends DynamicTexture {
|
||||
// By default, images are unblurred and not clamped.
|
||||
|
||||
if (textureData.getFilteringData().shouldBlur()) {
|
||||
IrisRenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
}
|
||||
|
||||
if (textureData.getFilteringData().shouldClamp()) {
|
||||
IrisRenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
IrisRenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.texture.TextureUploadHelper;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
@@ -20,18 +20,18 @@ public class NoiseTexture extends GlResource {
|
||||
int height;
|
||||
|
||||
public NoiseTexture(int width, int height) {
|
||||
super(IrisRenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
super(RenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
|
||||
int texture = getGlId();
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MIN_LOD, 0);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LOD,0);
|
||||
IrisRenderSystem.texParameterf(texture, GL11.GL_TEXTURE_2D, GL14.GL_TEXTURE_LOD_BIAS, 0.0F);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MIN_LOD, 0);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LOD,0);
|
||||
RenderSystem.texParameterf(texture, GL11.GL_TEXTURE_2D, GL14.GL_TEXTURE_LOD_BIAS, 0.0F);
|
||||
resize(texture, width, height);
|
||||
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
@@ -47,7 +47,7 @@ public class NoiseTexture extends GlResource {
|
||||
|
||||
// Since we're using tightly-packed RGB data, we must use an alignment of 1 byte instead of the usual 4 bytes.
|
||||
GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
|
||||
IrisRenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, width, height, 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, pixels);
|
||||
RenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, width, height, 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.texture.InternalTextureFormat;
|
||||
import net.coderbot.iris.gl.texture.PixelFormat;
|
||||
import net.coderbot.iris.gl.texture.PixelType;
|
||||
@@ -58,14 +58,14 @@ public class RenderTarget {
|
||||
private void setupTexture(int texture, int width, int height, boolean allowsLinear) {
|
||||
resizeTexture(texture, width, height);
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, allowsLinear ? GL11.GL_LINEAR : GL11.GL_NEAREST);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, allowsLinear ? GL11.GL_LINEAR : GL11.GL_NEAREST);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, allowsLinear ? GL11.GL_LINEAR : GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, allowsLinear ? GL11.GL_LINEAR : GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
|
||||
}
|
||||
|
||||
private void resizeTexture(int texture, int width, int height) {
|
||||
IrisRenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, internalFormat.getGlFormat(), width, height, 0, format.getGlFormat(), type.getGlFormat(), NULL_BUFFER);
|
||||
RenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, internalFormat.getGlFormat(), width, height, 0, format.getGlFormat(), type.getGlFormat(), NULL_BUFFER);
|
||||
}
|
||||
|
||||
void resize(Vector2i textureScaleOverride) {
|
||||
|
||||
@@ -2,8 +2,8 @@ package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
||||
import net.coderbot.iris.gl.texture.DepthBufferFormat;
|
||||
import net.coderbot.iris.gl.texture.DepthCopyStrategy;
|
||||
@@ -177,7 +177,7 @@ public class RenderTargets {
|
||||
translucentDepthDirty = false;
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, noTranslucents.getTextureId());
|
||||
depthSourceFb.bindAsReadBuffer();
|
||||
IrisRenderSystem.copyTexImage2D(GL11.GL_TEXTURE_2D, 0, currentDepthFormat.getGlInternalFormat(), 0, 0, cachedWidth, cachedHeight, 0);
|
||||
RenderSystem.copyTexImage2D(GL11.GL_TEXTURE_2D, 0, currentDepthFormat.getGlInternalFormat(), 0, 0, cachedWidth, cachedHeight, 0);
|
||||
} else {
|
||||
copyStrategy.copy(depthSourceFb, getDepthTexture(), noTranslucentsDestFb, noTranslucents.getTextureId(), getCurrentWidth(), getCurrentHeight());
|
||||
}
|
||||
@@ -188,7 +188,7 @@ public class RenderTargets {
|
||||
handDepthDirty = false;
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, noHand.getTextureId());
|
||||
depthSourceFb.bindAsReadBuffer();
|
||||
IrisRenderSystem.copyTexImage2D(GL11.GL_TEXTURE_2D, 0, currentDepthFormat.getGlInternalFormat(), 0, 0, cachedWidth, cachedHeight, 0);
|
||||
RenderSystem.copyTexImage2D(GL11.GL_TEXTURE_2D, 0, currentDepthFormat.getGlInternalFormat(), 0, 0, cachedWidth, cachedHeight, 0);
|
||||
} else {
|
||||
copyStrategy.copy(depthSourceFb, getDepthTexture(), noHandDestFb, noHand.getTextureId(), getCurrentWidth(), getCurrentHeight());
|
||||
}
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package net.coderbot.iris.rendertarget;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.gl.GlResource;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.texture.TextureUploadHelper;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -11,7 +11,7 @@ import java.nio.ByteBuffer;
|
||||
|
||||
public class SingleColorTexture extends GlResource {
|
||||
public SingleColorTexture(int red, int green, int blue, int alpha) {
|
||||
super(IrisRenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
super(RenderSystem.createTexture(GL11.GL_TEXTURE_2D));
|
||||
ByteBuffer pixel = BufferUtils.createByteBuffer(4);
|
||||
pixel.put((byte) red);
|
||||
pixel.put((byte) green);
|
||||
@@ -21,13 +21,13 @@ public class SingleColorTexture extends GlResource {
|
||||
|
||||
int texture = getGlId();
|
||||
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
|
||||
IrisRenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
|
||||
RenderSystem.texParameteri(texture, GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
|
||||
|
||||
TextureUploadHelper.resetTextureUploadState();
|
||||
IrisRenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, 1, 1, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixel);
|
||||
RenderSystem.texImage2D(texture, GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, 1, 1, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixel);
|
||||
}
|
||||
|
||||
public int getTextureId() {
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
package net.coderbot.iris.shaderpack;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
|
||||
import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap;
|
||||
@@ -7,12 +9,11 @@ import it.unimi.dsi.fastutil.objects.Object2FloatMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.blending.AlphaTest;
|
||||
import net.coderbot.iris.gl.blending.AlphaTestFunction;
|
||||
import net.coderbot.iris.gl.blending.AlphaTestOverride;
|
||||
import net.coderbot.iris.gl.blending.BlendMode;
|
||||
import net.coderbot.iris.gl.blending.BlendModeFunction;
|
||||
import net.coderbot.iris.gl.blending.BlendModeOverride;
|
||||
import net.coderbot.iris.gl.blending.BufferBlendInformation;
|
||||
@@ -41,51 +42,51 @@ import java.util.function.Consumer;
|
||||
* values in here & the values parsed from shader source code.
|
||||
*/
|
||||
public class ShaderProperties {
|
||||
private CloudSetting cloudSetting = CloudSetting.DEFAULT;
|
||||
private OptionalBoolean oldHandLight = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean dynamicHandLight = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean oldLighting = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowTerrain = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowTranslucent = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowEntities = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowPlayer = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowBlockEntities = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean underwaterOverlay = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean sun = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean moon = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean vignette = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean backFaceSolid = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean backFaceCutout = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean backFaceCutoutMipped = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean backFaceTranslucent = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean rainDepth = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean concurrentCompute = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean beaconBeamDepth = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean separateAo = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean frustumCulling = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowCulling = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean shadowEnabled = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean particlesBeforeDeferred = OptionalBoolean.DEFAULT;
|
||||
private OptionalBoolean prepareBeforeShadow = OptionalBoolean.DEFAULT;
|
||||
private List<String> sliderOptions = new ArrayList<>();
|
||||
private final Map<String, List<String>> profiles = new LinkedHashMap<>();
|
||||
@Getter private CloudSetting cloudSetting = CloudSetting.DEFAULT;
|
||||
@Getter private OptionalBoolean oldHandLight = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean dynamicHandLight = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean oldLighting = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowTerrain = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowTranslucent = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowEntities = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowPlayer = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowBlockEntities = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean underwaterOverlay = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean sun = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean moon = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean vignette = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean backFaceSolid = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean backFaceCutout = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean backFaceCutoutMipped = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean backFaceTranslucent = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean rainDepth = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean concurrentCompute = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean beaconBeamDepth = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean separateAo = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean frustumCulling = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowCulling = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean shadowEnabled = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean particlesBeforeDeferred = OptionalBoolean.DEFAULT;
|
||||
@Getter private OptionalBoolean prepareBeforeShadow = OptionalBoolean.DEFAULT;
|
||||
@Getter private List<String> sliderOptions = new ArrayList<>();
|
||||
@Getter private final Map<String, List<String>> profiles = new LinkedHashMap<>();
|
||||
private List<String> mainScreenOptions = null;
|
||||
private final Map<String, List<String>> subScreenOptions = new HashMap<>();
|
||||
@Getter private final Map<String, List<String>> subScreenOptions = new HashMap<>();
|
||||
private Integer mainScreenColumnCount = null;
|
||||
private final Map<String, Integer> subScreenColumnCount = new HashMap<>();
|
||||
@Getter private final Map<String, Integer> subScreenColumnCount = new HashMap<>();
|
||||
// TODO: private Map<String, String> optifineVersionRequirements;
|
||||
// TODO: Parse custom uniforms / variables
|
||||
private final Object2ObjectMap<String, AlphaTestOverride> alphaTestOverrides = new Object2ObjectOpenHashMap<>();
|
||||
private final Object2FloatMap<String> viewportScaleOverrides = new Object2FloatOpenHashMap<>();
|
||||
private final Object2ObjectMap<String, TextureScaleOverride> textureScaleOverrides = new Object2ObjectOpenHashMap<>();
|
||||
private final Object2ObjectMap<String, BlendModeOverride> blendModeOverrides = new Object2ObjectOpenHashMap<>();
|
||||
private final Object2ObjectMap<String, ArrayList<BufferBlendInformation>> bufferBlendOverrides = new Object2ObjectOpenHashMap<>();
|
||||
private final EnumMap<TextureStage, Object2ObjectMap<String, String>> customTextures = new EnumMap<>(TextureStage.class);
|
||||
private final Object2ObjectMap<String, Object2BooleanMap<String>> explicitFlips = new Object2ObjectOpenHashMap<>();
|
||||
@Getter private final Object2ObjectMap<String, AlphaTestOverride> alphaTestOverrides = new Object2ObjectOpenHashMap<>();
|
||||
@Getter private final Object2FloatMap<String> viewportScaleOverrides = new Object2FloatOpenHashMap<>();
|
||||
@Getter private final Object2ObjectMap<String, TextureScaleOverride> textureScaleOverrides = new Object2ObjectOpenHashMap<>();
|
||||
@Getter private final Object2ObjectMap<String, BlendModeOverride> blendModeOverrides = new Object2ObjectOpenHashMap<>();
|
||||
@Getter private final Object2ObjectMap<String, ArrayList<BufferBlendInformation>> bufferBlendOverrides = new Object2ObjectOpenHashMap<>();
|
||||
@Getter private final EnumMap<TextureStage, Object2ObjectMap<String, String>> customTextures = new EnumMap<>(TextureStage.class);
|
||||
@Getter private final Object2ObjectMap<String, Object2BooleanMap<String>> explicitFlips = new Object2ObjectOpenHashMap<>();
|
||||
private String noiseTexturePath = null;
|
||||
private Object2ObjectMap<String, String> conditionallyEnabledPrograms = new Object2ObjectOpenHashMap<>();
|
||||
private List<String> requiredFeatureFlags = new ArrayList<>();
|
||||
private List<String> optionalFeatureFlags = new ArrayList<>();
|
||||
@Getter private Object2ObjectMap<String, String> conditionallyEnabledPrograms = new Object2ObjectOpenHashMap<>();
|
||||
@Getter private List<String> requiredFeatureFlags = new ArrayList<>();
|
||||
@Getter private List<String> optionalFeatureFlags = new ArrayList<>();
|
||||
|
||||
private ShaderProperties() {
|
||||
// empty
|
||||
@@ -93,10 +94,10 @@ public class ShaderProperties {
|
||||
|
||||
// TODO: Is there a better solution than having ShaderPack pass a root path to ShaderProperties to be able to read textures?
|
||||
public ShaderProperties(String contents, ShaderPackOptions shaderPackOptions, Iterable<StringPair> environmentDefines) {
|
||||
String preprocessedContents = PropertiesPreprocessor.preprocessSource(contents, shaderPackOptions, environmentDefines);
|
||||
final String preprocessedContents = PropertiesPreprocessor.preprocessSource(contents, shaderPackOptions, environmentDefines);
|
||||
|
||||
Properties preprocessed = new OrderBackedProperties();
|
||||
Properties original = new OrderBackedProperties();
|
||||
final Properties preprocessed = new OrderBackedProperties();
|
||||
final Properties original = new OrderBackedProperties();
|
||||
try {
|
||||
preprocessed.load(new StringReader(preprocessedContents));
|
||||
original.load(new StringReader(contents));
|
||||
@@ -105,8 +106,8 @@ public class ShaderProperties {
|
||||
}
|
||||
|
||||
preprocessed.forEach((keyObject, valueObject) -> {
|
||||
String key = (String) keyObject;
|
||||
String value = (String) valueObject;
|
||||
final String key = (String) keyObject;
|
||||
final String value = (String) valueObject;
|
||||
|
||||
if ("texture.noise".equals(key)) {
|
||||
noiseTexturePath = value;
|
||||
@@ -154,7 +155,7 @@ public class ShaderProperties {
|
||||
// TODO: Custom uniforms
|
||||
|
||||
handlePassDirective("scale.", key, value, pass -> {
|
||||
float scale;
|
||||
final float scale;
|
||||
|
||||
try {
|
||||
scale = Float.parseFloat(value);
|
||||
@@ -167,7 +168,7 @@ public class ShaderProperties {
|
||||
});
|
||||
|
||||
handlePassDirective("size.buffer.", key, value, pass -> {
|
||||
String[] parts = value.split(" ");
|
||||
final String[] parts = value.split(" ");
|
||||
|
||||
if (parts.length != 2) {
|
||||
Iris.logger.error("Unable to parse size.buffer directive for " + pass + ": " + value);
|
||||
@@ -183,7 +184,7 @@ public class ShaderProperties {
|
||||
return;
|
||||
}
|
||||
|
||||
String[] parts = value.split(" ");
|
||||
final String[] parts = value.split(" ");
|
||||
|
||||
if (parts.length > 2) {
|
||||
Iris.logger.warn("Weird alpha test directive for " + pass + " contains more parts than we expected: " + value);
|
||||
@@ -192,14 +193,14 @@ public class ShaderProperties {
|
||||
return;
|
||||
}
|
||||
|
||||
Optional<AlphaTestFunction> function = AlphaTestFunction.fromString(parts[0]);
|
||||
final Optional<AlphaTestFunction> function = AlphaTestFunction.fromString(parts[0]);
|
||||
|
||||
if (!function.isPresent()) {
|
||||
Iris.logger.error("Unable to parse alpha test directive for " + pass + ", unknown alpha test function " + parts[0] + ": " + value);
|
||||
return;
|
||||
}
|
||||
|
||||
float reference;
|
||||
final float reference;
|
||||
|
||||
try {
|
||||
reference = Float.parseFloat(parts[1]);
|
||||
@@ -214,15 +215,15 @@ public class ShaderProperties {
|
||||
handlePassDirective("blend.", key, value, pass -> {
|
||||
if (pass.contains(".")) {
|
||||
|
||||
if (!IrisRenderSystem.supportsBufferBlending()) {
|
||||
if (!RenderSystem.supportsBufferBlending()) {
|
||||
throw new RuntimeException("Buffer blending is not supported on this platform, however it was attempted to be used!");
|
||||
}
|
||||
|
||||
String[] parts = pass.split("\\.");
|
||||
final String[] parts = pass.split("\\.");
|
||||
int index = PackRenderTargetDirectives.LEGACY_RENDER_TARGETS.indexOf(parts[1]);
|
||||
|
||||
if (index == -1 && parts[1].startsWith("colortex")) {
|
||||
String id = parts[1].substring("colortex".length());
|
||||
final String id = parts[1].substring("colortex".length());
|
||||
|
||||
try {
|
||||
index = Integer.parseInt(id);
|
||||
@@ -240,8 +241,8 @@ public class ShaderProperties {
|
||||
return;
|
||||
}
|
||||
|
||||
String[] modeArray = value.split(" ");
|
||||
int[] modes = new int[modeArray.length];
|
||||
final String[] modeArray = value.split(" ");
|
||||
final int[] modes = new int[modeArray.length];
|
||||
|
||||
int i = 0;
|
||||
for (String modeName : modeArray) {
|
||||
@@ -249,7 +250,7 @@ public class ShaderProperties {
|
||||
i++;
|
||||
}
|
||||
|
||||
bufferBlendOverrides.computeIfAbsent(parts[0], list -> new ArrayList<>()).add(new BufferBlendInformation(index, new BlendMode(modes[0], modes[1], modes[2], modes[3])));
|
||||
bufferBlendOverrides.computeIfAbsent(parts[0], list -> new ArrayList<>()).add(new BufferBlendInformation(index, new BlendState(modes[0], modes[1], modes[2], modes[3])));
|
||||
|
||||
return;
|
||||
}
|
||||
@@ -259,8 +260,8 @@ public class ShaderProperties {
|
||||
return;
|
||||
}
|
||||
|
||||
String[] modeArray = value.split(" ");
|
||||
int[] modes = new int[modeArray.length];
|
||||
final String[] modeArray = value.split(" ");
|
||||
final int[] modes = new int[modeArray.length];
|
||||
|
||||
int i = 0;
|
||||
for (String modeName : modeArray) {
|
||||
@@ -268,7 +269,7 @@ public class ShaderProperties {
|
||||
i++;
|
||||
}
|
||||
|
||||
blendModeOverrides.put(pass, new BlendModeOverride(new BlendMode(modes[0], modes[1], modes[2], modes[3])));
|
||||
blendModeOverrides.put(pass, new BlendModeOverride(new BlendState(modes[0], modes[1], modes[2], modes[3])));
|
||||
});
|
||||
|
||||
handleProgramEnabledDirective("program.", key, value, program -> {
|
||||
@@ -276,7 +277,7 @@ public class ShaderProperties {
|
||||
});
|
||||
|
||||
handleTwoArgDirective("texture.", key, value, (stageName, samplerName) -> {
|
||||
String[] parts = value.split(" ");
|
||||
final String[] parts = value.split(" ");
|
||||
|
||||
// TODO: Support raw textures
|
||||
if (parts.length > 1) {
|
||||
@@ -284,14 +285,14 @@ public class ShaderProperties {
|
||||
return;
|
||||
}
|
||||
|
||||
Optional<TextureStage> optionalTextureStage = TextureStage.parse(stageName);
|
||||
final Optional<TextureStage> optionalTextureStage = TextureStage.parse(stageName);
|
||||
|
||||
if (!optionalTextureStage.isPresent()) {
|
||||
Iris.logger.warn("Unknown texture stage " + "\"" + stageName + "\"," + " ignoring custom texture directive for " + key);
|
||||
return;
|
||||
}
|
||||
|
||||
TextureStage stage = optionalTextureStage.get();
|
||||
final TextureStage stage = optionalTextureStage.get();
|
||||
|
||||
customTextures.computeIfAbsent(stage, _stage -> new Object2ObjectOpenHashMap<>())
|
||||
.put(samplerName, value);
|
||||
@@ -314,8 +315,8 @@ public class ShaderProperties {
|
||||
|
||||
// We need to use a non-preprocessed property file here since we don't want any weird preprocessor changes to be applied to the screen/value layout.
|
||||
original.forEach((keyObject, valueObject) -> {
|
||||
String key = (String) keyObject;
|
||||
String value = (String) valueObject;
|
||||
final String key = (String) keyObject;
|
||||
final String value = (String) valueObject;
|
||||
|
||||
// Defining "sliders" multiple times in the properties file will only result in
|
||||
// the last definition being used, should be tested if behavior matches OptiFine
|
||||
@@ -365,7 +366,7 @@ public class ShaderProperties {
|
||||
}
|
||||
|
||||
try {
|
||||
int result = Integer.parseInt(value);
|
||||
final int result = Integer.parseInt(value);
|
||||
|
||||
handler.accept(result);
|
||||
} catch (NumberFormatException nex) {
|
||||
@@ -377,17 +378,17 @@ public class ShaderProperties {
|
||||
|
||||
private static boolean handleAffixedIntDirective(String prefix, String suffix, String key, String value, BiConsumer<String, Integer> handler) {
|
||||
if (key.startsWith(prefix) && key.endsWith(suffix)) {
|
||||
int substrBegin = prefix.length();
|
||||
int substrEnd = key.length() - suffix.length();
|
||||
final int substrBegin = prefix.length();
|
||||
final int substrEnd = key.length() - suffix.length();
|
||||
|
||||
if (substrEnd <= substrBegin) {
|
||||
return false;
|
||||
}
|
||||
|
||||
String affixStrippedKey = key.substring(substrBegin, substrEnd);
|
||||
final String affixStrippedKey = key.substring(substrBegin, substrEnd);
|
||||
|
||||
try {
|
||||
int result = Integer.parseInt(value);
|
||||
final int result = Integer.parseInt(value);
|
||||
|
||||
handler.accept(affixStrippedKey, result);
|
||||
} catch (NumberFormatException nex) {
|
||||
@@ -402,7 +403,7 @@ public class ShaderProperties {
|
||||
|
||||
private static void handlePassDirective(String prefix, String key, String value, Consumer<String> handler) {
|
||||
if (key.startsWith(prefix)) {
|
||||
String pass = key.substring(prefix.length());
|
||||
final String pass = key.substring(prefix.length());
|
||||
|
||||
handler.accept(pass);
|
||||
}
|
||||
@@ -410,7 +411,7 @@ public class ShaderProperties {
|
||||
|
||||
private static void handleProgramEnabledDirective(String prefix, String key, String value, Consumer<String> handler) {
|
||||
if (key.startsWith(prefix)) {
|
||||
String program = key.substring(prefix.length(), key.indexOf(".", prefix.length()));
|
||||
final String program = key.substring(prefix.length(), key.indexOf(".", prefix.length()));
|
||||
|
||||
handler.accept(program);
|
||||
}
|
||||
@@ -421,15 +422,15 @@ public class ShaderProperties {
|
||||
return;
|
||||
}
|
||||
|
||||
String[] elements = value.split(" +");
|
||||
final String[] elements = value.split(" +");
|
||||
|
||||
handler.accept(Arrays.asList(elements));
|
||||
}
|
||||
|
||||
private static void handlePrefixedWhitespacedListDirective(String prefix, String key, String value, BiConsumer<String, List<String>> handler) {
|
||||
if (key.startsWith(prefix)) {
|
||||
String prefixStrippedKey = key.substring(prefix.length());
|
||||
String[] elements = value.split(" +");
|
||||
final String prefixStrippedKey = key.substring(prefix.length());
|
||||
final String[] elements = value.split(" +");
|
||||
|
||||
handler.accept(prefixStrippedKey, Arrays.asList(elements));
|
||||
}
|
||||
@@ -437,9 +438,9 @@ public class ShaderProperties {
|
||||
|
||||
private static void handleTwoArgDirective(String prefix, String key, String value, BiConsumer<String, String> handler) {
|
||||
if (key.startsWith(prefix)) {
|
||||
int endOfPassIndex = key.indexOf(".", prefix.length());
|
||||
String stage = key.substring(prefix.length(), endOfPassIndex);
|
||||
String sampler = key.substring(endOfPassIndex + 1);
|
||||
final int endOfPassIndex = key.indexOf(".", prefix.length());
|
||||
final String stage = key.substring(prefix.length(), endOfPassIndex);
|
||||
final String sampler = key.substring(endOfPassIndex + 1);
|
||||
|
||||
handler.accept(stage, sampler);
|
||||
}
|
||||
@@ -449,175 +450,16 @@ public class ShaderProperties {
|
||||
return new ShaderProperties();
|
||||
}
|
||||
|
||||
public CloudSetting getCloudSetting() {
|
||||
return cloudSetting;
|
||||
}
|
||||
|
||||
public OptionalBoolean getOldHandLight() {
|
||||
return oldHandLight;
|
||||
}
|
||||
|
||||
public OptionalBoolean getDynamicHandLight() {
|
||||
return dynamicHandLight;
|
||||
}
|
||||
|
||||
public OptionalBoolean getOldLighting() {
|
||||
return oldLighting;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowTerrain() {
|
||||
return shadowTerrain;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowTranslucent() {
|
||||
return shadowTranslucent;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowEntities() {
|
||||
return shadowEntities;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowPlayer() {
|
||||
return shadowPlayer;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowBlockEntities() {
|
||||
return shadowBlockEntities;
|
||||
}
|
||||
|
||||
public OptionalBoolean getUnderwaterOverlay() {
|
||||
return underwaterOverlay;
|
||||
}
|
||||
|
||||
public OptionalBoolean getSun() {
|
||||
return sun;
|
||||
}
|
||||
|
||||
public OptionalBoolean getMoon() {
|
||||
return moon;
|
||||
}
|
||||
|
||||
public OptionalBoolean getVignette() {
|
||||
return vignette;
|
||||
}
|
||||
|
||||
public OptionalBoolean getBackFaceSolid() {
|
||||
return backFaceSolid;
|
||||
}
|
||||
|
||||
public OptionalBoolean getBackFaceCutout() {
|
||||
return backFaceCutout;
|
||||
}
|
||||
|
||||
public OptionalBoolean getBackFaceCutoutMipped() {
|
||||
return backFaceCutoutMipped;
|
||||
}
|
||||
|
||||
public OptionalBoolean getBackFaceTranslucent() {
|
||||
return backFaceTranslucent;
|
||||
}
|
||||
|
||||
public OptionalBoolean getRainDepth() {
|
||||
return rainDepth;
|
||||
}
|
||||
|
||||
public OptionalBoolean getBeaconBeamDepth() {
|
||||
return beaconBeamDepth;
|
||||
}
|
||||
|
||||
public OptionalBoolean getSeparateAo() {
|
||||
return separateAo;
|
||||
}
|
||||
|
||||
public OptionalBoolean getFrustumCulling() {
|
||||
return frustumCulling;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowCulling() {
|
||||
return shadowCulling;
|
||||
}
|
||||
|
||||
public OptionalBoolean getShadowEnabled() {
|
||||
return shadowEnabled;
|
||||
}
|
||||
|
||||
public OptionalBoolean getParticlesBeforeDeferred() {
|
||||
return particlesBeforeDeferred;
|
||||
}
|
||||
|
||||
public OptionalBoolean getConcurrentCompute() {
|
||||
return concurrentCompute;
|
||||
}
|
||||
|
||||
public OptionalBoolean getPrepareBeforeShadow() {
|
||||
return prepareBeforeShadow;
|
||||
}
|
||||
|
||||
public Object2ObjectMap<String, AlphaTestOverride> getAlphaTestOverrides() {
|
||||
return alphaTestOverrides;
|
||||
}
|
||||
|
||||
public Object2FloatMap<String> getViewportScaleOverrides() {
|
||||
return viewportScaleOverrides;
|
||||
}
|
||||
|
||||
public Object2ObjectMap<String, TextureScaleOverride> getTextureScaleOverrides() {
|
||||
return textureScaleOverrides;
|
||||
}
|
||||
|
||||
public Object2ObjectMap<String, BlendModeOverride> getBlendModeOverrides() {
|
||||
return blendModeOverrides;
|
||||
}
|
||||
|
||||
public Object2ObjectMap<String, ArrayList<BufferBlendInformation>> getBufferBlendOverrides() {
|
||||
return bufferBlendOverrides;
|
||||
}
|
||||
|
||||
public EnumMap<TextureStage, Object2ObjectMap<String, String>> getCustomTextures() {
|
||||
return customTextures;
|
||||
}
|
||||
|
||||
public Optional<String> getNoiseTexturePath() {
|
||||
public Optional<String> getNoiseTexturePath() {
|
||||
return Optional.ofNullable(noiseTexturePath);
|
||||
}
|
||||
|
||||
public Object2ObjectMap<String, String> getConditionallyEnabledPrograms() {
|
||||
return conditionallyEnabledPrograms;
|
||||
}
|
||||
|
||||
public List<String> getSliderOptions() {
|
||||
return sliderOptions;
|
||||
}
|
||||
|
||||
public Map<String, List<String>> getProfiles() {
|
||||
return profiles;
|
||||
}
|
||||
|
||||
public Optional<List<String>> getMainScreenOptions() {
|
||||
public Optional<List<String>> getMainScreenOptions() {
|
||||
return Optional.ofNullable(mainScreenOptions);
|
||||
}
|
||||
|
||||
public Map<String, List<String>> getSubScreenOptions() {
|
||||
return subScreenOptions;
|
||||
}
|
||||
|
||||
public Optional<Integer> getMainScreenColumnCount() {
|
||||
public Optional<Integer> getMainScreenColumnCount() {
|
||||
return Optional.ofNullable(mainScreenColumnCount);
|
||||
}
|
||||
|
||||
public Map<String, Integer> getSubScreenColumnCount() {
|
||||
return subScreenColumnCount;
|
||||
}
|
||||
|
||||
public Object2ObjectMap<String, Object2BooleanMap<String>> getExplicitFlips() {
|
||||
return explicitFlips;
|
||||
}
|
||||
|
||||
public List<String> getRequiredFeatureFlags() {
|
||||
return requiredFeatureFlags;
|
||||
}
|
||||
|
||||
public List<String> getOptionalFeatureFlags() {
|
||||
return optionalFeatureFlags;
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.shaderpack.loading;
|
||||
|
||||
import net.coderbot.iris.gl.blending.BlendMode;
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
import net.coderbot.iris.gl.blending.BlendModeFunction;
|
||||
import net.coderbot.iris.gl.blending.BlendModeOverride;
|
||||
|
||||
@@ -36,7 +36,7 @@ public enum ProgramId {
|
||||
EntitiesGlowing(ProgramGroup.Gbuffers, "entities_glowing", Entities),
|
||||
ArmorGlint(ProgramGroup.Gbuffers, "armor_glint", Textured),
|
||||
SpiderEyes(ProgramGroup.Gbuffers, "spidereyes", Textured,
|
||||
new BlendModeOverride(new BlendMode(BlendModeFunction.SRC_ALPHA.getGlId(), BlendModeFunction.ONE.getGlId(), BlendModeFunction.ZERO.getGlId(), BlendModeFunction.ONE.getGlId()))),
|
||||
new BlendModeOverride(new BlendState(BlendModeFunction.SRC_ALPHA.getGlId(), BlendModeFunction.ONE.getGlId(), BlendModeFunction.ZERO.getGlId(), BlendModeFunction.ONE.getGlId()))),
|
||||
|
||||
Hand(ProgramGroup.Gbuffers, "hand", TexturedLit),
|
||||
Weather(ProgramGroup.Gbuffers, "weather", TexturedLit),
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
package net.coderbot.iris.shadows;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import it.unimi.dsi.fastutil.ints.IntArrayList;
|
||||
import it.unimi.dsi.fastutil.ints.IntList;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
||||
import net.coderbot.iris.gl.texture.DepthBufferFormat;
|
||||
import net.coderbot.iris.gl.texture.DepthCopyStrategy;
|
||||
@@ -121,7 +121,7 @@ public class ShadowRenderTargets {
|
||||
public void copyPreTranslucentDepth() {
|
||||
if (translucentDepthDirty) {
|
||||
translucentDepthDirty = false;
|
||||
IrisRenderSystem.blitFramebuffer(depthSourceFb.getId(), noTranslucentsDestFb.getId(), 0, 0, resolution, resolution,
|
||||
RenderSystem.blitFramebuffer(depthSourceFb.getId(), noTranslucentsDestFb.getId(), 0, 0, resolution, resolution,
|
||||
0, 0, resolution, resolution, GL11.GL_DEPTH_BUFFER_BIT, GL11.GL_NEAREST);
|
||||
} else {
|
||||
DepthCopyStrategy.fastest(false).copy(depthSourceFb, mainDepth.getTextureId(), noTranslucentsDestFb, noTranslucents.getTextureId(),
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
package net.coderbot.iris.sodium.shader_overrides;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import me.jellysquid.mods.sodium.client.gl.device.RenderDevice;
|
||||
import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkProgram;
|
||||
import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderFogComponent;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.coderbot.iris.gl.program.ProgramImages;
|
||||
import net.coderbot.iris.gl.program.ProgramSamplers;
|
||||
import net.coderbot.iris.gl.program.ProgramUniforms;
|
||||
@@ -91,6 +91,6 @@ public class IrisChunkProgram extends ChunkProgram {
|
||||
|
||||
matrix.get(buffer);
|
||||
|
||||
IrisRenderSystem.uniformMatrix4fv(location, false, buffer);
|
||||
RenderSystem.uniformMatrix4fv(location, false, buffer);
|
||||
}
|
||||
}
|
||||
@@ -1,100 +0,0 @@
|
||||
package net.coderbot.iris.texture;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
public class TextureInfoCache {
|
||||
public static final TextureInfoCache INSTANCE = new TextureInfoCache();
|
||||
|
||||
private final Int2ObjectMap<TextureInfo> cache = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
private TextureInfoCache() {
|
||||
}
|
||||
|
||||
public TextureInfo getInfo(int id) {
|
||||
TextureInfo info = cache.get(id);
|
||||
if (info == null) {
|
||||
info = new TextureInfo(id);
|
||||
cache.put(id, info);
|
||||
}
|
||||
return info;
|
||||
}
|
||||
|
||||
public void onTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels) {
|
||||
if (level == 0) {
|
||||
int id = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
TextureInfo info = getInfo(id);
|
||||
info.internalFormat = internalformat;
|
||||
info.width = width;
|
||||
info.height = height;
|
||||
}
|
||||
}
|
||||
public void onTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, long pixels_buffer_offset) {
|
||||
if (level == 0) {
|
||||
int id = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
TextureInfo info = getInfo(id);
|
||||
info.internalFormat = internalformat;
|
||||
info.width = width;
|
||||
info.height = height;
|
||||
}
|
||||
}
|
||||
|
||||
public void onDeleteTexture(int id) {
|
||||
cache.remove(id);
|
||||
}
|
||||
|
||||
public static class TextureInfo {
|
||||
private final int id;
|
||||
private int internalFormat = -1;
|
||||
private int width = -1;
|
||||
private int height = -1;
|
||||
|
||||
private TextureInfo(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public int getInternalFormat() {
|
||||
if (internalFormat == -1) {
|
||||
internalFormat = fetchLevelParameter(GL11.GL_TEXTURE_INTERNAL_FORMAT);
|
||||
}
|
||||
return internalFormat;
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
if (width == -1) {
|
||||
width = fetchLevelParameter(GL11.GL_TEXTURE_WIDTH);
|
||||
}
|
||||
return width;
|
||||
}
|
||||
|
||||
public int getHeight() {
|
||||
if (height == -1) {
|
||||
height = fetchLevelParameter(GL11.GL_TEXTURE_HEIGHT);
|
||||
}
|
||||
return height;
|
||||
}
|
||||
|
||||
private int fetchLevelParameter(int pname) {
|
||||
// Keep track of what texture was bound before
|
||||
int previousTextureBinding = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
|
||||
// Bind this texture and grab the parameter from it.
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, id);
|
||||
int parameter = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, 0, pname);
|
||||
|
||||
// Make sure to re-bind the previous texture to avoid issues.
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, previousTextureBinding);
|
||||
|
||||
return parameter;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package net.coderbot.iris.texture.format;
|
||||
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.coderbot.iris.texture.mipmap.CustomMipmapGenerator;
|
||||
import net.coderbot.iris.texture.pbr.PBRType;
|
||||
import net.minecraft.client.renderer.texture.AbstractTexture;
|
||||
@@ -46,12 +46,12 @@ public interface TextureFormat {
|
||||
|
||||
default void setupTextureParameters(PBRType pbrType, AbstractTexture texture) {
|
||||
if (!canInterpolateValues(pbrType)) {
|
||||
int minFilter = IrisRenderSystem.getTexParameteri(texture.getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER);
|
||||
int minFilter = RenderSystem.getTexParameteri(texture.getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER);
|
||||
// Non-mipped filters begin at 0x2600 whereas mipped filters begin at 0x2700,
|
||||
// so this bit mask can be used to check if the filter is mipped or not
|
||||
boolean mipmap = (minFilter & 1 << 8) == 1;
|
||||
IrisRenderSystem.texParameteri(texture.getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mipmap ? GL11.GL_NEAREST_MIPMAP_NEAREST : GL11.GL_NEAREST);
|
||||
IrisRenderSystem.texParameteri(texture.getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(texture.getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mipmap ? GL11.GL_NEAREST_MIPMAP_NEAREST : GL11.GL_NEAREST);
|
||||
RenderSystem.texParameteri(texture.getGlTextureId(), GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
package net.coderbot.iris.texture.pbr;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureTracker;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gl.state.StateUpdateNotifiers;
|
||||
import net.coderbot.iris.rendertarget.NativeImageBackedSingleColorTexture;
|
||||
import net.coderbot.iris.texture.TextureTracker;
|
||||
import net.coderbot.iris.texture.pbr.loader.PBRTextureLoader;
|
||||
import net.coderbot.iris.texture.pbr.loader.PBRTextureLoader.PBRTextureConsumer;
|
||||
import net.coderbot.iris.texture.pbr.loader.PBRTextureLoaderRegistry;
|
||||
|
||||
@@ -1,13 +1,14 @@
|
||||
package net.coderbot.iris.texture.pbr.loader;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.NativeImage;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfo;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
|
||||
import com.gtnewhorizons.angelica.mixins.early.shaders.accessors.AnimationMetadataSectionAccessor;
|
||||
import com.gtnewhorizons.angelica.mixins.early.shaders.accessors.TextureAtlasSpriteAccessor;
|
||||
import com.gtnewhorizons.angelica.mixins.early.shaders.accessors.TextureMapAccessor;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.texture.TextureInfoCache;
|
||||
import net.coderbot.iris.texture.format.TextureFormat;
|
||||
import net.coderbot.iris.texture.format.TextureFormatLoader;
|
||||
import net.coderbot.iris.texture.mipmap.ChannelMipmapGenerator;
|
||||
@@ -42,7 +43,7 @@ public class AtlasPBRLoader implements PBRTextureLoader<TextureMap> {
|
||||
|
||||
@Override
|
||||
public void load(TextureMap texMap, IResourceManager resourceManager, PBRTextureConsumer pbrTextureConsumer) {
|
||||
final TextureInfoCache.TextureInfo textureInfo = TextureInfoCache.INSTANCE.getInfo(texMap.getGlTextureId());
|
||||
final TextureInfo textureInfo = TextureInfoCache.INSTANCE.getInfo(texMap.getGlTextureId());
|
||||
final int atlasWidth = textureInfo.getWidth();
|
||||
final int atlasHeight = textureInfo.getHeight();
|
||||
final int mipLevel = fetchAtlasMipLevel(texMap);
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
package net.coderbot.iris.texture.util;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import net.coderbot.iris.gl.IrisRenderSystem;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import org.lwjgl.BufferUtils;
|
||||
@@ -19,15 +18,13 @@ public class TextureManipulationUtil {
|
||||
colorFillFBO = OpenGlHelper.func_153165_e/*glGenFramebuffers*/();
|
||||
}
|
||||
|
||||
int previousFramebufferId = GL11.glGetInteger(GL30.GL_FRAMEBUFFER_BINDING);
|
||||
final int previousFramebufferId = GL11.glGetInteger(GL30.GL_FRAMEBUFFER_BINDING);
|
||||
// TODO: allocations
|
||||
FloatBuffer previousClearColorBuffer = BufferUtils.createFloatBuffer(4);
|
||||
// float[] previousClearColor = new float[4];
|
||||
IrisRenderSystem.getFloatv(GL11.GL_COLOR_CLEAR_VALUE, previousClearColorBuffer);
|
||||
int previousTextureId = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
IntBuffer previousViewportBuffer = BufferUtils.createIntBuffer(4);
|
||||
// int[] previousViewport = new int[4];
|
||||
IrisRenderSystem.getIntegerv(GL11.GL_VIEWPORT, previousViewportBuffer);
|
||||
final FloatBuffer previousClearColorBuffer = BufferUtils.createFloatBuffer(4);
|
||||
GL11.glGetFloat(GL11.GL_COLOR_CLEAR_VALUE, previousClearColorBuffer);
|
||||
final int previousTextureId = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
final IntBuffer previousViewportBuffer = BufferUtils.createIntBuffer(4);
|
||||
GL11.glGetInteger(GL11.GL_VIEWPORT, previousViewportBuffer);
|
||||
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, colorFillFBO);
|
||||
GL11.glClearColor(
|
||||
@@ -38,8 +35,8 @@ public class TextureManipulationUtil {
|
||||
);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, textureId);
|
||||
for (int level = 0; level <= maxLevel; ++level) {
|
||||
int width = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_WIDTH);
|
||||
int height = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_HEIGHT);
|
||||
final int width = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_WIDTH);
|
||||
final int height = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_HEIGHT);
|
||||
GL11.glViewport(0, 0, width, height);
|
||||
GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL11.GL_TEXTURE_2D, textureId, level);
|
||||
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
@@ -2,6 +2,9 @@ package net.coderbot.iris.uniforms;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.BlendState;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfo;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureTracker;
|
||||
import com.gtnewhorizons.angelica.mixins.early.shaders.accessors.EntityRendererAccessor;
|
||||
import net.coderbot.iris.gl.state.StateUpdateNotifiers;
|
||||
import net.coderbot.iris.gl.uniform.DynamicUniformHolder;
|
||||
@@ -9,8 +12,6 @@ import net.coderbot.iris.gl.uniform.UniformHolder;
|
||||
import net.coderbot.iris.layer.GbufferPrograms;
|
||||
import net.coderbot.iris.shaderpack.IdMap;
|
||||
import net.coderbot.iris.shaderpack.PackDirectives;
|
||||
import net.coderbot.iris.texture.TextureInfoCache;
|
||||
import net.coderbot.iris.texture.TextureTracker;
|
||||
import net.coderbot.iris.uniforms.transforms.SmoothedFloat;
|
||||
import net.coderbot.iris.uniforms.transforms.SmoothedVec2f;
|
||||
import net.minecraft.block.material.Material;
|
||||
@@ -65,7 +66,7 @@ public final class CommonUniforms {
|
||||
|
||||
final AbstractTexture texture = TextureTracker.INSTANCE.getTexture(glId);
|
||||
if (texture instanceof TextureMap) {
|
||||
final TextureInfoCache.TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
|
||||
return new Vector2i(info.getWidth(), info.getHeight());
|
||||
}
|
||||
|
||||
@@ -75,7 +76,7 @@ public final class CommonUniforms {
|
||||
uniforms.uniform2i("gtextureSize", () -> {
|
||||
final int glId = GLStateManager.getBoundTexture();
|
||||
|
||||
final TextureInfoCache.TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
|
||||
return new Vector2i(info.getWidth(), info.getHeight());
|
||||
|
||||
}, StateUpdateNotifiers.bindTextureNotifier);
|
||||
|
||||
@@ -79,6 +79,8 @@ sodium.options.always_defer_chunk_updates.name=Always Defer Chunk Updates
|
||||
sodium.options.always_defer_chunk_updates.tooltip=If enabled, rendering will never wait for chunk updates to finish, even if they are important. This can greatly improve frame rates in some scenarios, but it may create significant visual lag in the world.
|
||||
sodium.options.use_no_error_context.name=Use No Error Context
|
||||
sodium.options.use_no_error_context.tooltip=If enabled, the OpenGL context will be created with error checking disabled. This may slightly improve performance, but it also increases the risk that the game will crash instead of gracefully handling OpenGL errors. You should disable this option if you are experiencing sudden unexplained crashes.
|
||||
sodium.options.use_gl_state_cache.name=Use GL State Cache
|
||||
sodium.options.use_gl_state_cache.tooltip=If enabled, the OpenGL state cache will be used to reduce the number of redundant state changes. This can improve performance, but it may also cause issues with some mods. Does not persist across game restarts.
|
||||
sodium.options.threads.value=%s thread(s)
|
||||
sodium.options.default=Default
|
||||
sodium.options.buttons.undo=Undo
|
||||
|
||||
Reference in new issue
Block a user