mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-21 04:42:17 +00:00
Compare commits
16
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c942df386a | ||
|
|
1d24789362 | ||
|
|
b8b445322c | ||
|
|
38c72b7af0 | ||
|
|
466b0544e3 | ||
|
|
26da0c2b64 | ||
|
|
8c3ac9e310 | ||
|
|
6a7c2520d0 | ||
|
|
a0d782a1a5 | ||
|
|
aebaab8d6f | ||
|
|
05158317e8 | ||
|
|
4d39c90ba6 | ||
|
|
83cf0801ef | ||
|
|
db49a613a0 | ||
|
|
64087f53c5 | ||
|
|
efb039ff38 |
No files matched your search
@@ -7,6 +7,7 @@
|
||||
|
||||
|
||||
# Required Dependencies
|
||||
* [UniMixins](https://github.com/LegacyModdingMC/UniMixins/releases) >= 0.1.14
|
||||
* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.2.1
|
||||
|
||||
# Known (temporary) Incompatibilities
|
||||
|
||||
+2
-2
@@ -1,4 +1,4 @@
|
||||
//version: 1705357285
|
||||
//version: 1706545953
|
||||
/*
|
||||
DO NOT CHANGE THIS FILE!
|
||||
Also, you may replace this file at any time if there is an update available.
|
||||
@@ -651,7 +651,7 @@ repositories {
|
||||
|
||||
def mixinProviderGroup = "io.github.legacymoddingmc"
|
||||
def mixinProviderModule = "unimixins"
|
||||
def mixinProviderVersion = "0.1.13"
|
||||
def mixinProviderVersion = "0.1.15"
|
||||
def mixinProviderSpecNoClassifer = "${mixinProviderGroup}:${mixinProviderModule}:${mixinProviderVersion}"
|
||||
def mixinProviderSpec = "${mixinProviderSpecNoClassifer}:dev"
|
||||
ext.mixinProviderSpec = mixinProviderSpec
|
||||
|
||||
+1
-1
@@ -57,7 +57,7 @@ replaceGradleTokenInFile =
|
||||
# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise, you can
|
||||
# leave this property empty.
|
||||
# Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
|
||||
apiPackage =
|
||||
apiPackage = api
|
||||
|
||||
# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/
|
||||
# There can be multiple files in a comma-separated list.
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gtnewhorizons.angelica.api;
|
||||
|
||||
import java.lang.annotation.Documented;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
import static java.lang.annotation.ElementType.TYPE;
|
||||
import static java.lang.annotation.RetentionPolicy.RUNTIME;
|
||||
|
||||
/**
|
||||
* Marks an ISBRH as thread-safe, allowing Angelica to run it off-thread.
|
||||
*
|
||||
* <p>Note: Any tessellator access <i>must</i> be done within the methods of the ISBRH and not cached in the class.</p>
|
||||
*/
|
||||
@Documented
|
||||
@Target({ TYPE })
|
||||
@Retention(RUNTIME)
|
||||
public @interface ThreadSafeISBRH {
|
||||
/**
|
||||
* Specifies whether Angelica should create a thread local instance of the class for each thread.
|
||||
* <ul>
|
||||
* <li>If this is set to <tt>true</tt>, a new instance will be created using the default constructor on each thread.</li>
|
||||
* <ul>
|
||||
* <li>Note: If your renderer requires arguments to the constructor, do <i>not</i> use this annotation;
|
||||
* instead use the {@link ThreadSafeISBRHFactory} interface and implement the {@link ThreadSafeISBRHFactory#newInstance} method. </li>
|
||||
* </ul>
|
||||
* <li>If this is set to <tt>false</tt>, the main thread instance will be used on all threads.
|
||||
* Use this option if your renderer class has no state, and can be safely used from multiple threads as is.</li>
|
||||
* <ul>
|
||||
* <li>No state/non final variables should be stored in the ISBRH as it is not guaranteed to be thread safe.</li>
|
||||
* </ul>
|
||||
* </ul>
|
||||
*/
|
||||
boolean perThread();
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package com.gtnewhorizons.angelica.api;
|
||||
|
||||
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
|
||||
/**
|
||||
* Marks an ISBRH as thread-safe using a thread local instance, allowing Angelica to run it off-thread.
|
||||
* Use this when your ISBRH uses a non-default constructor.
|
||||
* <p>To avoid a hard dependency on Angelica, you will likely want to mark this as an optional interface using:</p>
|
||||
* <pre>
|
||||
* @Optional.Interface(modid = "angelica", iface = "com.gtnewhorizons.angelica.api.ThreadSafeISBRHFactory")
|
||||
* </pre>
|
||||
*
|
||||
* <p><b>Notes</b></p>
|
||||
* <ul>
|
||||
* <li>Any tessellator access <i>must</i> be done within the methods of the ISBRH and not cached in the class.</li>
|
||||
* <li>If your class uses a default constructor or is thread-safe by default, consider using the simpler {@link ThreadSafeISBRH}
|
||||
* annotation instead.
|
||||
* </ul>
|
||||
*/
|
||||
public interface ThreadSafeISBRHFactory extends ISimpleBlockRenderingHandler {
|
||||
ThreadSafeISBRHFactory newInstance();
|
||||
}
|
||||
@@ -3,13 +3,13 @@ package com.gtnewhorizons.angelica.client.renderer;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.Vector3dStack;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
|
||||
import com.gtnewhorizons.angelica.utils.ObjectPooler;
|
||||
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;
|
||||
|
||||
@@ -45,8 +45,7 @@ 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;
|
||||
private final Vector3dStack storedTranslation = new Vector3dStack();
|
||||
|
||||
public void setOffset(BlockPos pos) {
|
||||
this.offset.set(pos);
|
||||
@@ -142,19 +141,17 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
|
||||
}
|
||||
|
||||
public void storeTranslation() {
|
||||
if(translationStored) throw new IllegalStateException("Translation already stored!");
|
||||
translationStored = true;
|
||||
storedTranslation.push();
|
||||
|
||||
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;
|
||||
storedTranslation.pop();
|
||||
}
|
||||
|
||||
public static int createBrightness(int sky, int block) {
|
||||
|
||||
@@ -83,11 +83,6 @@ public class AngelicaConfig {
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean optimizeTextureLoading;
|
||||
|
||||
@Config.Comment("Optimize slow glGetInteger in Jabba w/ Nvidia Drivers")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean optimizeJabbaGetInteger;
|
||||
|
||||
@Config.Comment("Fix thread-safety in lotrs rendering")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
|
||||
@@ -55,7 +55,7 @@ public class Feature {
|
||||
, GLStateManager.clearColor // Color mode and index mode clear values
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_CURRENT_BIT, ImmutableSet.of(
|
||||
// Current RGBA color
|
||||
GLStateManager.color // Current RGBA color
|
||||
// Current color index
|
||||
// Current normal vector
|
||||
// Current texture coordinates
|
||||
@@ -84,7 +84,7 @@ public class Feature {
|
||||
// GL_DITHER flag
|
||||
, GLStateManager.fogMode // GL_FOG flag
|
||||
// GL_LIGHTi where 0 <= i < GL_MAX_LIGHTS
|
||||
// GL_LIGHTING flag
|
||||
, GLStateManager.lightingState // GL_LIGHTING flag
|
||||
// GL_LINE_SMOOTH flag
|
||||
// GL_LINE_STIPPLE flag
|
||||
// GL_INDEX_LOGIC_OP flag
|
||||
@@ -102,7 +102,7 @@ public class Feature {
|
||||
// GL_SAMPLE_ALPHA_TO_COVERAGE flag
|
||||
// GL_SAMPLE_ALPHA_TO_ONE flag
|
||||
// GL_SAMPLE_COVERAGE flag
|
||||
// GL_SCISSOR_TEST flag
|
||||
, GLStateManager.scissorTest // GL_SCISSOR_TEST flag
|
||||
// GL_STENCIL_TEST flag
|
||||
// GL_TEXTURE_1D flag
|
||||
// GL_TEXTURE_2D flag - Below
|
||||
@@ -148,7 +148,7 @@ public class Feature {
|
||||
// Ambient scene color
|
||||
// GL_LIGHT_MODEL_LOCAL_VIEWER value
|
||||
// GL_LIGHT_MODEL_TWO_SIDE setting
|
||||
// GL_LIGHTING enable bit
|
||||
GLStateManager.lightingState // GL_LIGHTING enable bit
|
||||
// Enable bit for each light
|
||||
// Ambient, diffuse, and specular intensity for each light
|
||||
// Direction, position, exponent, and cutoff angle for each light
|
||||
@@ -207,7 +207,7 @@ public class Feature {
|
||||
// Polygon stipple pattern
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_SCISSOR_BIT, ImmutableSet.of(
|
||||
// GL_SCISSOR_TEST enable bit
|
||||
GLStateManager.scissorTest // GL_SCISSOR_TEST enable bit
|
||||
// Scissor box
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_STENCIL_BUFFER_BIT, ImmutableSet.of(
|
||||
@@ -240,9 +240,9 @@ public class Feature {
|
||||
attribToFeatures.put(GL11.GL_TRANSFORM_BIT, ImmutableSet.of(
|
||||
// Coefficients of the six clipping planes
|
||||
// Enable bits for the user-definable clipping planes
|
||||
GLStateManager.matrixMode
|
||||
GLStateManager.matrixMode
|
||||
// GL_NORMALIZE flag
|
||||
// GL_RESCALE_NORMAL flag
|
||||
, GLStateManager.rescaleNormalState // GL_RESCALE_NORMAL flag
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_VIEWPORT_BIT, ImmutableSet.of(
|
||||
// Depth range (near and far)
|
||||
|
||||
@@ -24,10 +24,12 @@ import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import it.unimi.dsi.fastutil.ints.IntArrayList;
|
||||
import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
|
||||
import it.unimi.dsi.fastutil.ints.IntStack;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArraySet;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gbuffer_overrides.state.StateTracker;
|
||||
import net.coderbot.iris.gl.blending.AlphaTestStorage;
|
||||
@@ -78,6 +80,8 @@ public class GLStateManager {
|
||||
public static final int MAX_TEXTURE_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_TEXTURE_STACK_DEPTH);
|
||||
public static final int MAX_TEXTURE_UNITS = GL11.glGetInteger(GL20.GL_MAX_TEXTURE_IMAGE_UNITS);
|
||||
|
||||
public static final GLFeatureSet HAS_MULTIPLE_SET = new GLFeatureSet();
|
||||
|
||||
// GLStateManager State Trackers
|
||||
private static final IntStack attribs = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
|
||||
private static final IntStack activeTextureUnit = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
|
||||
@@ -107,7 +111,7 @@ public class GLStateManager {
|
||||
@Getter protected static final MatrixModeStack matrixMode = new MatrixModeStack();
|
||||
@Getter protected static final Matrix4fStack modelViewMatrix = new Matrix4fStack(MAX_MODELVIEW_STACK_DEPTH);
|
||||
@Getter protected static final Matrix4fStack projectionMatrix = new Matrix4fStack(MAX_PROJECTION_STACK_DEPTH);
|
||||
@Getter protected static final Matrix4fStack textureMatrix = new Matrix4fStack(MAX_TEXTURE_STACK_DEPTH);
|
||||
|
||||
|
||||
@Getter protected static final ViewPortStateStack viewportState = new ViewPortStateStack();
|
||||
|
||||
@@ -122,18 +126,52 @@ public class GLStateManager {
|
||||
private static Runnable fogDensityListener = null;
|
||||
|
||||
// Thread Checking
|
||||
@Getter
|
||||
private static final Thread MainThread = Thread.currentThread();
|
||||
@Getter private static final Thread MainThread = Thread.currentThread();
|
||||
private static Thread CurrentThread = MainThread;
|
||||
private static boolean runningSplash = false;
|
||||
@Setter @Getter private static boolean runningSplash = false;
|
||||
|
||||
private static int glListMode = 0;
|
||||
private static int glListId = -1;
|
||||
private static final Map<IStateStack<?>, ISettableState<?>> glListStates = new Object2ObjectArrayMap<>();
|
||||
private static final Int2ObjectMap<Set<Map.Entry<IStateStack<?>, ISettableState<?>>>> glListChanges = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
public static class GLFeatureSet extends IntOpenHashSet {
|
||||
public GLFeatureSet addFeature(int feature) {
|
||||
super.add(feature);
|
||||
return this;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static void init() {
|
||||
capabilities = GLContext.getCapabilities();
|
||||
HAS_MULTIPLE_SET
|
||||
.addFeature(GL11.GL_ACCUM_CLEAR_VALUE)
|
||||
.addFeature(GL11.GL_COLOR_CLEAR_VALUE)
|
||||
.addFeature(GL11.GL_COLOR_WRITEMASK)
|
||||
.addFeature(GL11.GL_CURRENT_COLOR)
|
||||
.addFeature(GL11.GL_CURRENT_NORMAL)
|
||||
.addFeature(GL11.GL_CURRENT_RASTER_COLOR)
|
||||
.addFeature(GL11.GL_CURRENT_RASTER_POSITION)
|
||||
.addFeature(GL11.GL_CURRENT_RASTER_TEXTURE_COORDS)
|
||||
.addFeature(GL11.GL_CURRENT_TEXTURE_COORDS)
|
||||
.addFeature(GL11.GL_DEPTH_RANGE)
|
||||
.addFeature(GL11.GL_FOG_COLOR)
|
||||
.addFeature(GL11.GL_LIGHT_MODEL_AMBIENT)
|
||||
.addFeature(GL11.GL_LINE_WIDTH_RANGE)
|
||||
.addFeature(GL11.GL_MAP1_GRID_DOMAIN)
|
||||
.addFeature(GL11.GL_MAP2_GRID_DOMAIN)
|
||||
.addFeature(GL11.GL_MAP2_GRID_SEGMENTS)
|
||||
.addFeature(GL11.GL_MAX_VIEWPORT_DIMS)
|
||||
.addFeature(GL11.GL_MODELVIEW_MATRIX)
|
||||
.addFeature(GL11.GL_POINT_SIZE_RANGE)
|
||||
.addFeature(GL11.GL_POLYGON_MODE)
|
||||
.addFeature(GL11.GL_PROJECTION_MATRIX)
|
||||
.addFeature(GL11.GL_SCISSOR_BOX)
|
||||
.addFeature(GL11.GL_TEXTURE_ENV_COLOR)
|
||||
.addFeature(GL11.GL_TEXTURE_MATRIX)
|
||||
.addFeature(GL11.GL_VIEWPORT);
|
||||
|
||||
RenderSystem.initRenderer();
|
||||
|
||||
if (AngelicaConfig.enableIris) {
|
||||
@@ -165,6 +203,10 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean shouldBypassCache() {
|
||||
return BYPASS_CACHE || runningSplash;
|
||||
}
|
||||
|
||||
// LWJGL Overrides
|
||||
public static void glEnable(int cap) {
|
||||
switch (cap) {
|
||||
@@ -212,7 +254,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static boolean glGetBoolean(int pname) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
if(shouldBypassCache()) {
|
||||
return GL11.glGetBoolean(pname);
|
||||
}
|
||||
return switch (pname) {
|
||||
@@ -230,8 +272,8 @@ public class GLStateManager {
|
||||
};
|
||||
}
|
||||
|
||||
private static void glGetBoolean(int pname, ByteBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
public static void glGetBoolean(int pname, ByteBuffer params) {
|
||||
if(shouldBypassCache()) {
|
||||
GL11.glGetBoolean(pname, params);
|
||||
return;
|
||||
}
|
||||
@@ -243,53 +285,72 @@ public class GLStateManager {
|
||||
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);
|
||||
default -> {
|
||||
if(!HAS_MULTIPLE_SET.contains(pname)) {
|
||||
params.put(0, (byte) (glGetBoolean(pname) ? GL11.GL_TRUE : GL11.GL_FALSE));
|
||||
} else {
|
||||
GL11.glGetBoolean(pname, params);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static int glGetInteger(int pname) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
if(shouldBypassCache()) {
|
||||
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_ALPHA_TEST_FUNC -> alphaState.getFunction();
|
||||
case GL11.GL_DEPTH_FUNC -> depthState.getFunc();
|
||||
case GL11.GL_LIST_MODE -> glListMode;
|
||||
case GL11.GL_MATRIX_MODE -> matrixMode.getMode();
|
||||
case GL11.GL_TEXTURE_BINDING_2D -> getBoundTexture();
|
||||
case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
|
||||
case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
|
||||
case GL14.GL_BLEND_SRC_ALPHA -> blendState.getSrcAlpha();
|
||||
case GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
|
||||
|
||||
default -> GL11.glGetInteger(pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static void glGetInteger(int pname, IntBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
if(shouldBypassCache()) {
|
||||
GL11.glGetInteger(pname, params);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (pname) {
|
||||
case GL11.GL_VIEWPORT -> viewportState.get(params);
|
||||
default -> GL11.glGetInteger(pname, params);
|
||||
default -> {
|
||||
if(!HAS_MULTIPLE_SET.contains(pname)) {
|
||||
params.put(0, glGetInteger(pname));
|
||||
} else {
|
||||
GL11.glGetInteger(pname, params);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void glGetFloat(int pname, FloatBuffer params) {
|
||||
if(GLStateManager.BYPASS_CACHE) {
|
||||
if(shouldBypassCache()) {
|
||||
GL11.glGetFloat(pname, params);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (pname) {
|
||||
case GL11.GL_MODELVIEW_MATRIX -> modelViewMatrix.get(params);
|
||||
case GL11.GL_PROJECTION_MATRIX -> projectionMatrix.get(params);
|
||||
case GL11.GL_TEXTURE_MATRIX -> textureMatrix.get(params);
|
||||
case GL11.GL_MODELVIEW_MATRIX -> modelViewMatrix.get(0, params);
|
||||
case GL11.GL_PROJECTION_MATRIX -> projectionMatrix.get(0, params);
|
||||
case GL11.GL_TEXTURE_MATRIX -> textures.getTextureUnitMatrix(getActiveTextureUnit()).get(0, params);
|
||||
case GL11.GL_COLOR_CLEAR_VALUE -> clearColor.get(params);
|
||||
default -> GL11.glGetFloat(pname, params);
|
||||
default -> {
|
||||
if(!HAS_MULTIPLE_SET.contains(pname)) {
|
||||
params.put(0, glGetFloat(pname));
|
||||
} else {
|
||||
GL11.glGetFloat(pname, params);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -342,7 +403,7 @@ public class GLStateManager {
|
||||
OpenGlHelper.glBlendFunc(srcFactor, dstFactor, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
return;
|
||||
}
|
||||
if (GLStateManager.BYPASS_CACHE || blendState.getSrcRgb() != srcFactor || blendState.getDstRgb() != dstFactor) {
|
||||
if (shouldBypassCache() || blendState.getSrcRgb() != srcFactor || blendState.getDstRgb() != dstFactor) {
|
||||
blendState.setSrcRgb(srcFactor);
|
||||
blendState.setDstRgb(dstFactor);
|
||||
GL11.glBlendFunc(srcFactor, dstFactor);
|
||||
@@ -363,7 +424,7 @@ public class GLStateManager {
|
||||
srcAlpha = GL11.GL_ONE;
|
||||
dstAlpha = GL11.GL_ONE_MINUS_SRC_ALPHA;
|
||||
}
|
||||
if (GLStateManager.BYPASS_CACHE || blendState.getSrcRgb() != srcRgb || blendState.getDstRgb() != dstRgb || blendState.getSrcAlpha()
|
||||
if (shouldBypassCache() || blendState.getSrcRgb() != srcRgb || blendState.getDstRgb() != dstRgb || blendState.getSrcAlpha()
|
||||
!= srcAlpha || blendState.getDstAlpha() != dstAlpha) {
|
||||
blendState.setSrcRgb(srcRgb);
|
||||
blendState.setDstRgb(dstRgb);
|
||||
@@ -377,8 +438,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glDepthFunc(int func) {
|
||||
// Hacky workaround for now, need to figure out why this isn't being applied...
|
||||
if (GLStateManager.BYPASS_CACHE || func != depthState.getFunc() || GLStateManager.runningSplash) {
|
||||
if (shouldBypassCache() || func != depthState.getFunc() ) {
|
||||
depthState.setFunc(func);
|
||||
GL11.glDepthFunc(func);
|
||||
}
|
||||
@@ -456,7 +516,7 @@ public class GLStateManager {
|
||||
|
||||
private static boolean changeColor(float red, float green, float blue, float alpha) {
|
||||
// Helper function for glColor*
|
||||
if (GLStateManager.BYPASS_CACHE || red != color.getRed() || green != color.getGreen() || blue != color.getBlue() || alpha != color.getAlpha()) {
|
||||
if (shouldBypassCache() || red != color.getRed() || green != color.getGreen() || blue != color.getBlue() || alpha != color.getAlpha()) {
|
||||
color.setRed(red);
|
||||
color.setGreen(green);
|
||||
color.setBlue(blue);
|
||||
@@ -479,7 +539,7 @@ public class GLStateManager {
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (GLStateManager.BYPASS_CACHE || red != colorMask.red || green != colorMask.green || blue != colorMask.blue || alpha != colorMask.alpha) {
|
||||
if (shouldBypassCache() || red != colorMask.red || green != colorMask.green || blue != colorMask.blue || alpha != colorMask.alpha) {
|
||||
colorMask.red = red;
|
||||
colorMask.green = green;
|
||||
colorMask.blue = blue;
|
||||
@@ -490,7 +550,7 @@ public class GLStateManager {
|
||||
|
||||
// Clear Color
|
||||
public static void glClearColor(float red, float green, float blue, float alpha) {
|
||||
if (GLStateManager.BYPASS_CACHE || red != clearColor.getRed() || green != clearColor.getGreen() || blue != clearColor.getBlue() || alpha != clearColor.getAlpha()) {
|
||||
if (shouldBypassCache() || red != clearColor.getRed() || green != clearColor.getGreen() || blue != clearColor.getBlue() || alpha != clearColor.getAlpha()) {
|
||||
clearColor.setRed(red);
|
||||
clearColor.setGreen(green);
|
||||
clearColor.setBlue(blue);
|
||||
@@ -535,7 +595,7 @@ public class GLStateManager {
|
||||
// Textures
|
||||
public static void glActiveTexture(int texture) {
|
||||
final int newTexture = texture - GL13.GL_TEXTURE0;
|
||||
if (GLStateManager.BYPASS_CACHE || getActiveTextureUnit() != newTexture) {
|
||||
if (shouldBypassCache() || getActiveTextureUnit() != newTexture) {
|
||||
activeTextureUnit.popInt();
|
||||
activeTextureUnit.push(newTexture);
|
||||
GL13.glActiveTexture(texture);
|
||||
@@ -544,7 +604,7 @@ public class GLStateManager {
|
||||
|
||||
public static void glActiveTextureARB(int texture) {
|
||||
final int newTexture = texture - GL13.GL_TEXTURE0;
|
||||
if (GLStateManager.BYPASS_CACHE || getActiveTextureUnit() != newTexture) {
|
||||
if (shouldBypassCache() || getActiveTextureUnit() != newTexture) {
|
||||
activeTextureUnit.popInt();
|
||||
activeTextureUnit.push(newTexture);
|
||||
ARBMultitexture.glActiveTextureARB(texture);
|
||||
@@ -568,7 +628,7 @@ public class GLStateManager {
|
||||
|
||||
final TextureBinding textureUnit = textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt());
|
||||
|
||||
if (GLStateManager.BYPASS_CACHE || textureUnit.getBinding() != texture || runningSplash) {
|
||||
if (shouldBypassCache() || textureUnit.getBinding() != texture) {
|
||||
GL11.glBindTexture(target, texture);
|
||||
textureUnit.setBinding(texture);
|
||||
TextureTracker.INSTANCE.onBindTexture(texture);
|
||||
@@ -598,7 +658,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glDeleteTextures(IntBuffer ids) {
|
||||
for(int i = 0; i < ids.capacity(); i++) {
|
||||
for(int i = 0; i < ids.remaining(); i++) {
|
||||
onDeleteTexture(ids.get(i));
|
||||
}
|
||||
|
||||
@@ -741,7 +801,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void fogColor(float red, float green, float blue, float alpha) {
|
||||
if (GLStateManager.BYPASS_CACHE || red != fogState.getFogColor().x || green != fogState.getFogColor().y || blue != fogState.getFogColor().z || alpha != fogState.getFogAlpha()) {
|
||||
if (shouldBypassCache() || red != fogState.getFogColor().x || green != fogState.getFogColor().y || blue != fogState.getFogColor().z || alpha != fogState.getFogAlpha()) {
|
||||
fogState.getFogColor().set(red, green, blue);
|
||||
fogState.setFogAlpha(alpha);
|
||||
fogState.getFogColorBuffer().clear();
|
||||
@@ -790,7 +850,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glShadeModel(int mode) {
|
||||
if (GLStateManager.BYPASS_CACHE || modelShadeMode != mode) {
|
||||
if (shouldBypassCache() || modelShadeMode != mode) {
|
||||
modelShadeMode = mode;
|
||||
GL11.glShadeModel(mode);
|
||||
}
|
||||
@@ -805,10 +865,6 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
|
||||
public static void setRunningSplash(boolean runningSplash) {
|
||||
GLStateManager.runningSplash = runningSplash;
|
||||
}
|
||||
|
||||
public static void makeCurrent(Drawable drawable) throws LWJGLException {
|
||||
drawable.makeCurrent();
|
||||
final Thread currentThread = Thread.currentThread();
|
||||
@@ -904,6 +960,10 @@ public class GLStateManager {
|
||||
matrixMode.setMode(mode);
|
||||
}
|
||||
|
||||
public static void glLoadMatrix(FloatBuffer m) {
|
||||
getMatrixStack().set(m);
|
||||
}
|
||||
|
||||
public static Matrix4fStack getMatrixStack() {
|
||||
switch (matrixMode.getMode()) {
|
||||
case GL11.GL_MODELVIEW -> {
|
||||
@@ -913,7 +973,7 @@ public class GLStateManager {
|
||||
return projectionMatrix;
|
||||
}
|
||||
case GL11.GL_TEXTURE -> {
|
||||
return textureMatrix;
|
||||
return textures.getTextureUnitMatrix(getActiveTextureUnit());
|
||||
}
|
||||
default -> throw new IllegalStateException("Unknown matrix mode: " + matrixMode.getMode());
|
||||
}
|
||||
@@ -1030,37 +1090,37 @@ public class GLStateManager {
|
||||
|
||||
|
||||
public static boolean updateTexParameteriCache(int target, int texture, int pname, int param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
if (target != GL11.GL_TEXTURE_2D) {
|
||||
return true;
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texture);
|
||||
switch (pname) {
|
||||
case GL11.GL_TEXTURE_MIN_FILTER -> {
|
||||
if(info.getMinFilter() == param) return false;
|
||||
if(info.getMinFilter() == param && !shouldBypassCache()) return false;
|
||||
info.setMinFilter(param);
|
||||
}
|
||||
case GL11.GL_TEXTURE_MAG_FILTER -> {
|
||||
if(info.getMagFilter() == param) return false;
|
||||
if(info.getMagFilter() == param && !shouldBypassCache()) return false;
|
||||
info.setMagFilter(param);
|
||||
}
|
||||
case GL11.GL_TEXTURE_WRAP_S -> {
|
||||
if(info.getWrapS() == param) return false;
|
||||
if(info.getWrapS() == param && !shouldBypassCache()) return false;
|
||||
info.setWrapS(param);
|
||||
}
|
||||
case GL11.GL_TEXTURE_WRAP_T -> {
|
||||
if(info.getWrapT() == param) return false;
|
||||
if(info.getWrapT() == param && !shouldBypassCache()) return false;
|
||||
info.setWrapT(param);
|
||||
}
|
||||
case GL12.GL_TEXTURE_MAX_LEVEL -> {
|
||||
if(info.getMaxLevel() == param) return false;
|
||||
if(info.getMaxLevel() == param && !shouldBypassCache()) return false;
|
||||
info.setMaxLevel(param);
|
||||
}
|
||||
case GL12.GL_TEXTURE_MIN_LOD -> {
|
||||
if(info.getMinLod() == param) return false;
|
||||
if(info.getMinLod() == param && !shouldBypassCache()) return false;
|
||||
info.setMinLod(param);
|
||||
}
|
||||
case GL12.GL_TEXTURE_MAX_LOD -> {
|
||||
if(info.getMaxLod() == param) return false;
|
||||
if(info.getMaxLod() == param && !shouldBypassCache()) return false;
|
||||
info.setMaxLod(param);
|
||||
}
|
||||
}
|
||||
@@ -1069,7 +1129,7 @@ public class GLStateManager {
|
||||
|
||||
|
||||
public static void glTexParameter(int target, int pname, IntBuffer params) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE || params.remaining() != 1 ) {
|
||||
if (target != GL11.GL_TEXTURE_2D || params.remaining() != 1 ) {
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
return;
|
||||
}
|
||||
@@ -1079,7 +1139,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glTexParameter(int target, int pname, FloatBuffer params) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE || params.remaining() != 1 ) {
|
||||
if (target != GL11.GL_TEXTURE_2D || params.remaining() != 1 ) {
|
||||
GL11.glTexParameter(target, pname, params);
|
||||
return;
|
||||
}
|
||||
@@ -1090,7 +1150,7 @@ public class GLStateManager {
|
||||
|
||||
|
||||
public static void glTexParameteri(int target, int pname, int param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
if (target != GL11.GL_TEXTURE_2D) {
|
||||
GL11.glTexParameteri(target, pname, param);
|
||||
return;
|
||||
}
|
||||
@@ -1101,17 +1161,17 @@ public class GLStateManager {
|
||||
|
||||
|
||||
public static boolean updateTexParameterfCache(int target, int texture, int pname, float param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
if (target != GL11.GL_TEXTURE_2D) {
|
||||
return true;
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texture);
|
||||
switch (pname) {
|
||||
case EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT -> {
|
||||
if(info.getMaxAnisotropy() == param) return false;
|
||||
if(info.getMaxAnisotropy() == param && !shouldBypassCache()) return false;
|
||||
info.setMaxAnisotropy(param);
|
||||
}
|
||||
case GL14.GL_TEXTURE_LOD_BIAS -> {
|
||||
if(info.getLodBias() == param) return false;
|
||||
if(info.getLodBias() == param && !shouldBypassCache()) return false;
|
||||
info.setLodBias(param);
|
||||
}
|
||||
}
|
||||
@@ -1119,7 +1179,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glTexParameterf(int target, int pname, float param) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
if (target != GL11.GL_TEXTURE_2D) {
|
||||
GL11.glTexParameterf(target, pname, param);
|
||||
return;
|
||||
}
|
||||
@@ -1143,14 +1203,14 @@ public class GLStateManager {
|
||||
};
|
||||
}
|
||||
public static int glGetTexParameteri(int target, int pname) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
if (target != GL11.GL_TEXTURE_2D || shouldBypassCache()) {
|
||||
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) {
|
||||
if (target != GL11.GL_TEXTURE_2D || shouldBypassCache()) {
|
||||
return GL11.glGetTexParameterf(target, pname);
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(getBoundTexture());
|
||||
@@ -1163,7 +1223,7 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static int glGetTexLevelParameteri(int target, int level, int pname) {
|
||||
if (target != GL11.GL_TEXTURE_2D || GLStateManager.BYPASS_CACHE) {
|
||||
if (target != GL11.GL_TEXTURE_2D || shouldBypassCache()) {
|
||||
return GL11.glGetTexLevelParameteri(target, level, pname);
|
||||
}
|
||||
final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(getBoundTexture());
|
||||
|
||||
@@ -0,0 +1,483 @@
|
||||
package com.gtnewhorizons.angelica.glsm.debug;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
// Adapted from https://github.com/makamys/CoreTweaks/blob/master/src/main/java/makamys/coretweaks/util/OpenGLDebugging.java;
|
||||
// originally from https://github.com/TheGreyGhost/MinecraftByExample/blob/1-8final/src/main/java/minecraftbyexample/usefultools/OpenGLdebugging.java
|
||||
|
||||
public class OpenGLDebugging {
|
||||
|
||||
public static final Logger LOGGER = LogManager.getLogger("gldumper");
|
||||
|
||||
private static final Consumer<String> LINE_LOGGER = LOGGER::debug;
|
||||
public static final String GL_IS_ENABLED = "glIsEnabled()";
|
||||
public static final String GL_GET_BOOLEANV = "glGetBooleanv()";
|
||||
public static final String GL_GET_INTEGERV = "glGetIntegerv()";
|
||||
public static final String GL_GET_FLOATV = "glGetFloatv()";
|
||||
|
||||
public class GLproperty {
|
||||
|
||||
public GLproperty(int init_gLconstant, String init_name, String init_description, String init_category, String init_fetchCommand) {
|
||||
gLConstant = init_gLconstant;
|
||||
name = init_name;
|
||||
description = init_description;
|
||||
category = init_category;
|
||||
fetchCommand = init_fetchCommand;
|
||||
}
|
||||
|
||||
public int gLConstant;
|
||||
public String name;
|
||||
public String description;
|
||||
public String category;
|
||||
public String fetchCommand;
|
||||
|
||||
final ByteBuffer byteBuffer = BufferUtils.createByteBuffer(16);
|
||||
|
||||
final IntBuffer intBuffer = BufferUtils.createIntBuffer(16);
|
||||
final FloatBuffer floatBuffer = BufferUtils.createFloatBuffer(16);
|
||||
|
||||
public String getAsString(boolean glsm) {
|
||||
switch(fetchCommand) {
|
||||
case GL_IS_ENABLED: {
|
||||
return "" + (glsm ? GLStateManager.glIsEnabled(gLConstant) : GL11.glIsEnabled(gLConstant));
|
||||
}
|
||||
case GL_GET_BOOLEANV: {
|
||||
if(GLStateManager.HAS_MULTIPLE_SET.contains(gLConstant)) {
|
||||
byteBuffer.clear();
|
||||
if(glsm) {
|
||||
GLStateManager.glGetBoolean(gLConstant, byteBuffer);
|
||||
} else {
|
||||
GL11.glGetBoolean(gLConstant, byteBuffer);
|
||||
}
|
||||
final StringBuilder out = new StringBuilder();
|
||||
for (int i = 0; i < byteBuffer.capacity(); ++i) {
|
||||
out.append(i == 0 ? "" : ", ").append(byteBuffer.get(i));
|
||||
}
|
||||
return out.toString();
|
||||
} else {
|
||||
return "" + (glsm ? GLStateManager.glGetBoolean(gLConstant) : GL11.glGetBoolean(gLConstant));
|
||||
}
|
||||
}
|
||||
case GL_GET_INTEGERV: {
|
||||
if(GLStateManager.HAS_MULTIPLE_SET.contains(gLConstant)) {
|
||||
intBuffer.clear();
|
||||
if(glsm) {
|
||||
GLStateManager.glGetInteger(gLConstant, intBuffer);
|
||||
} else {
|
||||
GL11.glGetInteger(gLConstant, intBuffer);
|
||||
}
|
||||
final StringBuilder out = new StringBuilder();
|
||||
for (int i = 0; i < intBuffer.remaining(); ++i) {
|
||||
out.append(i == 0 ? "" : ", ").append(intBuffer.get(i));
|
||||
}
|
||||
return out.toString();
|
||||
} else {
|
||||
return "" + (glsm ? GLStateManager.glGetInteger(gLConstant) : GL11.glGetInteger(gLConstant));
|
||||
}
|
||||
}
|
||||
case GL_GET_FLOATV: {
|
||||
if(GLStateManager.HAS_MULTIPLE_SET.contains(gLConstant)) {
|
||||
floatBuffer.clear();
|
||||
if(glsm) {
|
||||
GLStateManager.glGetFloat(gLConstant, floatBuffer);
|
||||
} else {
|
||||
GL11.glGetFloat(gLConstant, floatBuffer);
|
||||
}
|
||||
final StringBuilder out = new StringBuilder();
|
||||
for (int i = 0; i < floatBuffer.remaining(); ++i) {
|
||||
out.append(i == 0 ? "" : ", ").append(String.format("%f", floatBuffer.get(i)));
|
||||
}
|
||||
return out.toString();
|
||||
} else {
|
||||
return "" + (glsm ? GLStateManager.glGetFloat(gLConstant) : GL11.glGetFloat(gLConstant));
|
||||
}
|
||||
}
|
||||
default: return "";
|
||||
}
|
||||
|
||||
}
|
||||
final Matrix4f cachedMatrix = new Matrix4f();
|
||||
final Matrix4f uncachedMatrix = new Matrix4f();
|
||||
public Matrix4f getAsMatrix4f(boolean glsm) {
|
||||
if(!fetchCommand.equals(GL_GET_FLOATV)) {
|
||||
throw new IllegalArgumentException("This property does not return a matrix");
|
||||
}
|
||||
floatBuffer.clear();
|
||||
if(glsm) {
|
||||
GLStateManager.glGetFloat(gLConstant, floatBuffer);
|
||||
return cachedMatrix.set(0, floatBuffer);
|
||||
} else {
|
||||
GL11.glGetFloat(gLConstant, floatBuffer);
|
||||
return uncachedMatrix.set(0, floatBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
public static OpenGLDebugging instance = new OpenGLDebugging();
|
||||
|
||||
public GLproperty[] propertyList = {
|
||||
new GLproperty(GL11.GL_ACCUM_ALPHA_BITS, "GL_ACCUM_ALPHA_BITS", "Number of bits per alpha component in the accumulation buffer", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ACCUM_BLUE_BITS, "GL_ACCUM_BLUE_BITS", "Number of bits per blue component in the accumulation buffer", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ACCUM_CLEAR_VALUE, "GL_ACCUM_CLEAR_VALUE", "Accumulation-buffer clear value", "accum-buffer", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_ACCUM_GREEN_BITS, "GL_ACCUM_GREEN_BITS", "Number of bits per green component in the accumulation buffer", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ACCUM_RED_BITS, "GL_ACCUM_RED_BITS", "Number of bits per red component in the accumulation buffer", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ALPHA_BITS, "GL_ALPHA_BITS", "Number of bits per alpha component in color buffers", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ALPHA_TEST, "GL_ALPHA_TEST", "Alpha test enabled", "color-buffer/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_ALPHA_TEST_FUNC, "GL_ALPHA_TEST_FUNC", "Alpha test function", "color-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ALPHA_TEST_REF, "GL_ALPHA_TEST_REF", "Alpha test reference value", "color-buffer", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_AMBIENT, "GL_AMBIENT", "Ambient intensity of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_AMBIENT, "GL_AMBIENT", "Ambient material color", "lighting", "glGetMaterialfv()"),
|
||||
new GLproperty(GL11.GL_ATTRIB_STACK_DEPTH, "GL_ATTRIB_STACK_DEPTH", "Attribute stack pointer", "current", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_AUTO_NORMAL, "GL_AUTO_NORMAL", "True if automatic normal generation enabled", "eval", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_AUX_BUFFERS, "GL_AUX_BUFFERS", "Number of auxiliary buffers", "capability", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_BLEND, "GL_BLEND", "Blending enabled", "color-buffer/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_BLEND_DST, "GL_BLEND_DST", "Blending destination function", "color-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_BLEND_SRC, "GL_BLEND_SRC", "Blending source function", "color-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_BLUE_BITS, "GL_BLUE_BITS", "Number of bits per blue component in color buffers", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH, "GL_CLIENT_ATTRIB_STACK_DEPTH", "Client attribute stack pointer", "current", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_COEFF, "GL_COEFF", "1D control points", "capability", "glGetMapfv()"),
|
||||
new GLproperty(GL11.GL_COEFF, "GL_COEFF", "2D control points", "capability", "glGetMapfv()"),
|
||||
new GLproperty(GL11.GL_COLOR_ARRAY, "GL_COLOR_ARRAY", "RGBA color array enable", "vertex-array", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_COLOR_ARRAY_POINTER, "GL_COLOR_ARRAY_POINTER", "Pointer to the color array", "vertex-array", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_COLOR_ARRAY_SIZE, "GL_COLOR_ARRAY_SIZE", "Colors per vertex", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_COLOR_ARRAY_STRIDE, "GL_COLOR_ARRAY_STRIDE", "Stride between colors", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_COLOR_ARRAY_TYPE, "GL_COLOR_ARRAY_TYPE", "Type of color components", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_COLOR_CLEAR_VALUE, "GL_COLOR_CLEAR_VALUE", "Color-buffer clear value (RGBA mode)", "color-buffer", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_COLOR_INDEXES, "GL_COLOR_INDEXES", "ca, cd, and cs for color-index lighting", "lighting/e nable", "glGetMaterialfv()"),
|
||||
new GLproperty(GL11.GL_COLOR_LOGIC_OP, "GL_COLOR_LOGIC_OP", "RGBA color logical operation enabled", "color-buffer/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_COLOR_MATERIAL, "GL_COLOR_MATERIAL", "True if color tracking is enabled", "lighting", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_COLOR_MATERIAL_FACE, "GL_COLOR_MATERIAL_FACE", "Face(s) affected by color tracking", "lighting", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_COLOR_MATERIAL_PARAMETER, "GL_COLOR_MATERIAL_PARAMETER", "Material properties tracking current color", "lighting", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_COLOR_WRITEMASK, "GL_COLOR_WRITEMASK", "Color write enables; R, G, B, or A", "color-buffer", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_CONSTANT_ATTENUATION, "GL_CONSTANT_ATTENUATION", "Constant attenuation factor", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_CULL_FACE, "GL_CULL_FACE", "Polygon culling enabled", "polygon/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_CULL_FACE_MODE, "GL_CULL_FACE_MODE", "Cull front-/back-facing polygons", "polygon", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_CURRENT_COLOR, "GL_CURRENT_COLOR", "Current color", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_INDEX, "GL_CURRENT_INDEX", "Current color index", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_NORMAL, "GL_CURRENT_NORMAL", "Current normal", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_RASTER_COLOR, "GL_CURRENT_RASTER_COLOR", "Color associated with raster position", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_RASTER_DISTANCE, "GL_CURRENT_RASTER_DISTANCE", "Current raster distance", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_RASTER_INDEX, "GL_CURRENT_RASTER_INDEX", "Color index associated with raster position", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_RASTER_POSITION, "GL_CURRENT_RASTER_POSITION", "Current raster position", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_RASTER_POSITION_VALID, "GL_CURRENT_RASTER_POSITION_VALID", "Raster position valid bit", "current", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_CURRENT_RASTER_TEXTURE_COORDS, "GL_CURRENT_RASTER_TEXTURE_COORDS", "Texture coordinates associated with raster position", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_CURRENT_TEXTURE_COORDS, "GL_CURRENT_TEXTURE_COORDS", "Current texture coordinates", "current", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_DEPTH_BITS, "GL_DEPTH_BITS", "Number of depth-buffer bitplanes", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_DEPTH_CLEAR_VALUE, "GL_DEPTH_CLEAR_VALUE", "Depth-buffer clear value", "depth-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_DEPTH_FUNC, "GL_DEPTH_FUNC", "Depth buffer test function", "depth-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_DEPTH_RANGE, "GL_DEPTH_RANGE", "Depth range near and far", "viewport", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_DEPTH_TEST, "GL_DEPTH_TEST", "Depth buffer enabled", "depth-buffer/ena ble", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_DEPTH_WRITEMASK, "GL_DEPTH_WRITEMASK", "Depth buffer enabled for writing", "depth-buffer", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_DIFFUSE, "GL_DIFFUSE", "Diffuse intensity of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_DIFFUSE, "GL_DIFFUSE", "Diffuse material color", "lighting", "glGetMaterialfv()"),
|
||||
new GLproperty(GL11.GL_DITHER, "GL_DITHER", "Dithering enabled", "color-buffer/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_DOMAIN, "GL_DOMAIN", "1D domain endpoints", "capability", "glGetMapfv()"),
|
||||
new GLproperty(GL11.GL_DOMAIN, "GL_DOMAIN", "2D domain endpoints", "capability", "glGetMapfv()"),
|
||||
new GLproperty(GL11.GL_DOUBLEBUFFER, "GL_DOUBLEBUFFER", "True if front and back buffers exist", "capability", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_DRAW_BUFFER, "GL_DRAW_BUFFER", "Buffers selected for drawing", "color-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_EDGE_FLAG, "GL_EDGE_FLAG", "Edge flag", "current", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_EDGE_FLAG_ARRAY, "GL_EDGE_FLAG_ARRAY", "Edge flag array enable", "vertex-array", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_EDGE_FLAG_ARRAY_POINTER, "GL_EDGE_FLAG_ARRAY_POINTER", "Pointer to the edge flag array", "vertex-array", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_EDGE_FLAG_ARRAY_STRIDE, "GL_EDGE_FLAG_ARRAY_STRIDE", "Stride between edge flags", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_EMISSION, "GL_EMISSION", "Emissive material color", "lighting", "glGetMaterialfv()"),
|
||||
new GLproperty(GL11.GL_EYE_PLANE, "GL_EYE_PLANE", "Texgen plane equation coefficients", "texture", "glGetTexGenfv()"),
|
||||
new GLproperty(GL11.GL_FEEDBACK_BUFFER_POINTER, "GL_FEEDBACK_BUFFER_POINTER", "Pointer to feedback buffer", "feedback", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_FEEDBACK_BUFFER_SIZE, "GL_FEEDBACK_BUFFER_SIZE", "Size of feedback buffer", "feedback", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_FEEDBACK_BUFFER_TYPE, "GL_FEEDBACK_BUFFER_TYPE", "Type of feedback buffer", "feedback", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_FOG, "GL_FOG", "True if fog enabled", "fog/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_FOG_COLOR, "GL_FOG_COLOR", "Fog color", "fog", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_FOG_DENSITY, "GL_FOG_DENSITY", "Exponential fog density", "fog", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_FOG_END, "GL_FOG_END", "Linear fog end", "fog", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_FOG_HINT, "GL_FOG_HINT", "Fog hint", "hint", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_FOG_INDEX, "GL_FOG_INDEX", "Fog index", "fog", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_FOG_MODE, "GL_FOG_MODE", "Fog mode", "fog", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_FOG_START, "GL_FOG_START", "Linear fog start", "fog", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_FRONT_FACE, "GL_FRONT_FACE", "Polygon front-face CW/CCW indicator", "polygon", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_GREEN_BITS, "GL_GREEN_BITS", "Number of bits per green component in color buffers", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_INDEX_ARRAY, "GL_INDEX_ARRAY", "Color-index array enable", "vertex-array", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_INDEX_ARRAY_POINTER, "GL_INDEX_ARRAY_POINTER", "Pointer to the index array", "vertex-array", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_INDEX_ARRAY_STRIDE, "GL_INDEX_ARRAY_STRIDE", "Stride between color indices", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_INDEX_ARRAY_TYPE, "GL_INDEX_ARRAY_TYPE", "Type of color indices", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_INDEX_BITS, "GL_INDEX_BITS", "Number of bits per index in color buffers", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_INDEX_CLEAR_VALUE, "GL_INDEX_CLEAR_VALUE", "Color-buffer clear value (color-index mode)", "color-buffer", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_INDEX_LOGIC_OP, "GL_INDEX_LOGIC_OP", "Color index logical operation enabled", "color-buffer/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_INDEX_MODE, "GL_INDEX_MODE", "True if color buffers store indices", "capability", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_INDEX_OFFSET, "GL_INDEX_OFFSET", "Value of GL_INDEX_OFFSET", "pixel", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_INDEX_SHIFT, "GL_INDEX_SHIFT", "Value of GL_INDEX_SHIFT", "pixel", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_INDEX_WRITEMASK, "GL_INDEX_WRITEMASK", "Color-index writemask", "color-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LIGHT0, "GL_LIGHT0", "True if light 0 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT1, "GL_LIGHT1", "True if light 1 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT2, "GL_LIGHT2", "True if light 2 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT3, "GL_LIGHT3", "True if light 3 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT4, "GL_LIGHT4", "True if light 4 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT5, "GL_LIGHT5", "True if light 5 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT6, "GL_LIGHT6", "True if light 6 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT7, "GL_LIGHT7", "True if light 7 enabled", "lighting/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHTING, "GL_LIGHTING", "True if lighting is enabled", "lighting/e nable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LIGHT_MODEL_AMBIENT, "GL_LIGHT_MODEL_AMBIENT", "Ambient scene color", "lighting", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_LIGHT_MODEL_LOCAL_VIEWER, "GL_LIGHT_MODEL_LOCAL_VIEWER", "Viewer is local", "lighting", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_LIGHT_MODEL_TWO_SIDE, "GL_LIGHT_MODEL_TWO_SIDE", "Use two-sided lighting", "lighting", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_LINEAR_ATTENUATION, "GL_LINEAR_ATTENUATION", "Linear attenuation factor", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_LINE_SMOOTH, "GL_LINE_SMOOTH", "Line antialiasing on", "line/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LINE_SMOOTH_HINT, "GL_LINE_SMOOTH_HINT", "Line smooth hint", "hint", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LINE_STIPPLE, "GL_LINE_STIPPLE", "Line stipple enable", "line/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_LINE_STIPPLE_PATTERN, "GL_LINE_STIPPLE_PATTERN", "Line stipple", "line", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LINE_STIPPLE_REPEAT, "GL_LINE_STIPPLE_REPEAT", "Line stipple repeat", "line", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LINE_WIDTH, "GL_LINE_WIDTH", "Line width", "line", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_LINE_WIDTH_GRANULARITY, "GL_LINE_WIDTH_GRANULARITY", "Antialiased line-width granularity", "capability", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_LINE_WIDTH_RANGE, "GL_LINE_WIDTH_RANGE", "Range (low to high) of antialiased line widths", "capability", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_LIST_BASE, "GL_LIST_BASE", "Setting of glListBase()", "list", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LIST_INDEX, "GL_LIST_INDEX", "Number of display list under construction; 0 if none", "current", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LIST_MODE, "GL_LIST_MODE", "Mode of display list under construction; undefined if none", "current", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_LOGIC_OP_MODE, "GL_LOGIC_OP_MODE", "Logical operation function", "color-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAP1_GRID_DOMAIN, "GL_MAP1_GRID_DOMAIN", "1D grid endpoints", "eval", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_MAP1_GRID_SEGMENTS, "GL_MAP1_GRID_SEGMENTS", "1D grid divisions", "eval", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_MAP2_GRID_DOMAIN, "GL_MAP2_GRID_DOMAIN", "2D grid endpoints", "eval", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_MAP2_GRID_SEGMENTS, "GL_MAP2_GRID_SEGMENTS", "2D grid divisions", "eval", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_MAP_COLOR, "GL_MAP_COLOR", "True if colors are mapped", "pixel", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_MAP_STENCIL, "GL_MAP_STENCIL", "True if stencil values are mapped", "pixel", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_MATRIX_MODE, "GL_MATRIX_MODE", "Current matrix mode", "transform", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH", "Maximum depth of the attribute stack", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", "Maximum depth of the client attribute stack", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES", "Maximum number of user clipping planes", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER", "Maximum evaluator polynomial order", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_LIGHTS, "GL_MAX_LIGHTS", "Maximum number of lights", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING", "Maximum display-list call nesting", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH", "Maximum modelview-matrix stack depth", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH", "Maximum selection-name stack depth", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE", "Maximum size of a glPixelMap() translation table", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH", "Maximum projection-matrix stack depth", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE", "See discussion in Texture Proxy in Chapter 9", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH", "Maximum depth of texture matrix stack", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS", "Maximum viewport dimensions", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_MODELVIEW_MATRIX, "GL_MODELVIEW_MATRIX", "Modelview matrix stack", "matrix", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_MODELVIEW_STACK_DEPTH, "GL_MODELVIEW_STACK_DEPTH", "Modelview matrix stack pointer", "matrix", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_NAME_STACK_DEPTH, "GL_NAME_STACK_DEPTH", "Name stack depth", "current", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_NORMALIZE, "GL_NORMALIZE", "Current normal normalization on/off", "transform/ enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_NORMAL_ARRAY, "GL_NORMAL_ARRAY", "Normal array enable", "vertex-array", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_NORMAL_ARRAY_POINTER, "GL_NORMAL_ARRAY_POINTER", "Pointer to the normal array", "vertex-array", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_NORMAL_ARRAY_STRIDE, "GL_NORMAL_ARRAY_STRIDE", "Stride between normals", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_NORMAL_ARRAY_TYPE, "GL_NORMAL_ARRAY_TYPE", "Type of normal coordinates", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_OBJECT_PLANE, "GL_OBJECT_PLANE", "Texgen object linear coefficients", "texture", "glGetTexGenfv()"),
|
||||
new GLproperty(GL11.GL_ORDER, "GL_ORDER", "1D map order", "capability", "glGetMapiv()"),
|
||||
new GLproperty(GL11.GL_ORDER, "GL_ORDER", "2D map orders", "capability", "glGetMapiv()"),
|
||||
new GLproperty(GL11.GL_PACK_ALIGNMENT, "GL_PACK_ALIGNMENT", "Value of GL_PACK_ALIGNMENT", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_PACK_LSB_FIRST, "GL_PACK_LSB_FIRST", "Value of GL_PACK_LSB_FIRST", "pixel-store", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_PACK_ROW_LENGTH, "GL_PACK_ROW_LENGTH", "Value of GL_PACK_ROW_LENGTH", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_PACK_SKIP_PIXELS, "GL_PACK_SKIP_PIXELS", "Value of GL_PACK_SKIP_PIXELS", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_PACK_SKIP_ROWS, "GL_PACK_SKIP_ROWS", "Value of GL_PACK_SKIP_ROWS", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_PACK_SWAP_BYTES, "GL_PACK_SWAP_BYTES", "Value of GL_PACK_SWAP_BYTES", "pixel-store", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_PERSPECTIVE_CORRECTION_HINT, "GL_PERSPECTIVE_CORRECTION_HINT", "Perspective correction hint", "hint", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_POINT_SIZE, "GL_POINT_SIZE", "Point size", "point", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_POINT_SIZE_GRANULARITY, "GL_POINT_SIZE_GRANULARITY", "Antialiased point-size granularity", "capability", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_POINT_SIZE_RANGE, "GL_POINT_SIZE_RANGE", "Range (low to high) of antialiased point sizes", "capability", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_POINT_SMOOTH, "GL_POINT_SMOOTH", "Point antialiasing on", "point/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_POINT_SMOOTH_HINT, "GL_POINT_SMOOTH_HINT", "Point smooth hint", "hint", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_POLYGON_MODE, "GL_POLYGON_MODE", "Polygon rasterization mode (front and back)", "polygon", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_POLYGON_OFFSET_FACTOR, "GL_POLYGON_OFFSET_FACTOR", "Polygon offset factor", "polygon", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_POLYGON_OFFSET_FILL, "GL_POLYGON_OFFSET_FILL", "Polygon offset enable for GL_FILL mode rasterization", "polygon/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_POLYGON_OFFSET_LINE, "GL_POLYGON_OFFSET_LINE", "Polygon offset enable for GL_LINE mode rasterization", "polygon/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_POLYGON_OFFSET_POINT, "GL_POLYGON_OFFSET_POINT", "Polygon offset enable for GL_POINT mode rasterization", "polygon/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_POLYGON_SMOOTH, "GL_POLYGON_SMOOTH", "Polygon antialiasing on", "polygon/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_POLYGON_SMOOTH_HINT, "GL_POLYGON_SMOOTH_HINT", "Polygon smooth hint", "hint", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_POLYGON_STIPPLE, "GL_POLYGON_STIPPLE", "Polygon stipple enable", "polygon/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_POSITION, "GL_POSITION", "Position of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_PROJECTION_MATRIX, "GL_PROJECTION_MATRIX", "Projection matrix stack", "matrix", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_PROJECTION_STACK_DEPTH, "GL_PROJECTION_STACK_DEPTH", "Projection matrix stack pointer", "matrix", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_QUADRATIC_ATTENUATION, "GL_QUADRATIC_ATTENUATION", "Quadratic attenuation factor", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_READ_BUFFER, "GL_READ_BUFFER", "Read source buffer", "pixel", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_RED_BITS, "GL_RED_BITS", "Number of bits per red component in color buffers", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_RENDER_MODE, "GL_RENDER_MODE", "glRenderMode() setting", "current", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_RGBA_MODE, "GL_RGBA_MODE", "True if color buffers store RGBA", "capability", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_SCISSOR_BOX, "GL_SCISSOR_BOX", "Scissor box", "scissor", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_SCISSOR_TEST, "GL_SCISSOR_TEST", "Scissoring enabled", "scissor/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_SELECTION_BUFFER_POINTER, "GL_SELECTION_BUFFER_POINTER", "Pointer to selection buffer", "select", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_SELECTION_BUFFER_SIZE, "GL_SELECTION_BUFFER_SIZE", "Size of selection buffer", "select", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_SHADE_MODEL, "GL_SHADE_MODEL", "glShadeModel() setting", "lighting", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_SHININESS, "GL_SHININESS", "Specular exponent of material", "lighting", "glGetMaterialfv()"),
|
||||
new GLproperty(GL11.GL_SPECULAR, "GL_SPECULAR", "Specular intensity of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_SPECULAR, "GL_SPECULAR", "Specular material color", "lighting", "glGetMaterialfv()"),
|
||||
new GLproperty(GL11.GL_SPOT_CUTOFF, "GL_SPOT_CUTOFF", "Spotlight angle of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_SPOT_DIRECTION, "GL_SPOT_DIRECTION", "Spotlight direction of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_SPOT_EXPONENT, "GL_SPOT_EXPONENT", "Spotlight exponent of light i", "lighting", "glGetLightfv()"),
|
||||
new GLproperty(GL11.GL_STENCIL_BITS, "GL_STENCIL_BITS", "Number of stencil bitplanes", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_CLEAR_VALUE, "GL_STENCIL_CLEAR_VALUE", "Stencil-buffer clear value", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_FAIL, "GL_STENCIL_FAIL", "Stencil fail action", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_FUNC, "GL_STENCIL_FUNC", "Stencil function", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_PASS_DEPTH_FAIL, "GL_STENCIL_PASS_DEPTH_FAIL", "Stencil depth buffer fail action", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_PASS_DEPTH_PASS, "GL_STENCIL_PASS_DEPTH_PASS", "Stencil depth buffer pass action", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_REF, "GL_STENCIL_REF", "Stencil reference value", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_TEST, "GL_STENCIL_TEST", "Stenciling enabled", "stencil-buffer/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_STENCIL_VALUE_MASK, "GL_STENCIL_VALUE_MASK", "Stencil mask", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STENCIL_WRITEMASK, "GL_STENCIL_WRITEMASK", "Stencil-buffer writemask", "stencil-buffer", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_STEREO, "GL_STEREO", "True if left and right buffers exist", "capability", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_SUBPIXEL_BITS, "GL_SUBPIXEL_BITS", "Number of bits of subpixel precision in x and y", "capability", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE, "GL_TEXTURE", "x-D texture image at level of detail i", "UNUSED", "glGetTexImage()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_1D, "GL_TEXTURE_1D", "True if 1-D texturing enabled ", "texture/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_2D, "GL_TEXTURE_2D", "True if 2-D texturing enabled ", "texture/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_ALPHA_SIZE, "GL_TEXTURE_ALPHA_SIZE", "x-D texture image i's alpha resolution", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_BINDING_1D, "GL_TEXTURE_BINDING_1D", "Texture object bound to GL_TEXTURE_1D", "texture", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE_BINDING_2D, "GL_TEXTURE_BINDING_2D", "Texture object bound to GL_TEXTURE_2D", "texture", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE_BLUE_SIZE, "GL_TEXTURE_BLUE_SIZE", "x-D texture image i's blue resolution", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_BORDER, "GL_TEXTURE_BORDER", "x-D texture image i's border width", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_BORDER_COLOR, "GL_TEXTURE_BORDER_COLOR", "Texture border color", "texture", "glGetTexParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY, "GL_TEXTURE_COORD_ARRAY", "Texture coordinate array enable", "vertex-array", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_POINTER, "GL_TEXTURE_COORD_ARRAY_POINTER", "Pointer to the texture coordinate array", "vertex-array", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_SIZE, "GL_TEXTURE_COORD_ARRAY_SIZE", "Texture coordinates per element", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_STRIDE, "GL_TEXTURE_COORD_ARRAY_STRIDE", "Stride between texture coordinates", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_TYPE, "GL_TEXTURE_COORD_ARRAY_TYPE", "Type of texture coordinates", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE_ENV_COLOR, "GL_TEXTURE_ENV_COLOR", "Texture environment color", "texture", "glGetTexEnvfv()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_ENV_MODE, "GL_TEXTURE_ENV_MODE", "Texture application function", "texture", "glGetTexEnviv()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_GEN_MODE, "GL_TEXTURE_GEN_MODE", "Function used for texgen", "texture", "glGetTexGeniv()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_GEN_Q, "GL_TEXTURE_GEN_Q", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_GEN_R, "GL_TEXTURE_GEN_R", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_GEN_S, "GL_TEXTURE_GEN_S", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_GEN_T, "GL_TEXTURE_GEN_T", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_TEXTURE_GREEN_SIZE, "GL_TEXTURE_GREEN_SIZE", "x-D texture image i's green resolution", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_HEIGHT, "GL_TEXTURE_HEIGHT", "x-D texture image i's height", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_INTENSITY_SIZE, "GL_TEXTURE_INTENSITY_SIZE", "x-D texture image i's intensity resolution", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_LUMINANCE_SIZE, "GL_TEXTURE_LUMINANCE_SIZE", "x-D texture image i's luminance resolution", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_MAG_FILTER, "GL_TEXTURE_MAG_FILTER", "Texture magnification function", "texture", "glGetTexParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_MATRIX, "GL_TEXTURE_MATRIX", "Texture matrix stack", "matrix", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_TEXTURE_MIN_FILTER, "GL_TEXTURE_MIN_FILTER", "Texture minification function", "texture", "glGetTexParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_PRIORITY, "GL_TEXTURE_PRIORITY", "Texture object priority", "texture", "glGetTexParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_RED_SIZE, "GL_TEXTURE_RED_SIZE", "x-D texture image i's red resolution", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_STACK_DEPTH, "GL_TEXTURE_STACK_DEPTH", "Texture matrix stack pointer", "matrix", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_TEXTURE_WIDTH, "GL_TEXTURE_WIDTH", "x-D texture image i's width", "UNUSED", "glGetTexLevelParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_WRAP_S, "GL_TEXTURE_WRAP_S", "Texture wrap mode (x is S or T)", "texture", "glGetTexParameter*()"),
|
||||
new GLproperty(GL11.GL_TEXTURE_WRAP_T, "GL_TEXTURE_WRAP_T", "Texture wrap mode (x is S or T)", "texture", "glGetTexParameter*()"),
|
||||
new GLproperty(GL11.GL_UNPACK_ALIGNMENT, "GL_UNPACK_ALIGNMENT", "Value of GL_UNPACK_ALIGNMENT", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_UNPACK_LSB_FIRST, "GL_UNPACK_LSB_FIRST", "Value of GL_UNPACK_LSB_FIRST", "pixel-store", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_UNPACK_ROW_LENGTH, "GL_UNPACK_ROW_LENGTH", "Value of GL_UNPACK_ROW_LENGTH", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_UNPACK_SKIP_PIXELS, "GL_UNPACK_SKIP_PIXELS", "Value of GL_UNPACK_SKIP_PIXELS", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_UNPACK_SKIP_ROWS, "GL_UNPACK_SKIP_ROWS", "Value of GL_UNPACK_SKIP_ROWS", "pixel-store", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_UNPACK_SWAP_BYTES, "GL_UNPACK_SWAP_BYTES", "Value of GL_UNPACK_SWAP_BYTES", "pixel-store", GL_GET_BOOLEANV),
|
||||
new GLproperty(GL11.GL_VERTEX_ARRAY, "GL_VERTEX_ARRAY", "Vertex array enable", "vertex-array", GL_IS_ENABLED),
|
||||
new GLproperty(GL11.GL_VERTEX_ARRAY_POINTER, "GL_VERTEX_ARRAY_POINTER", "Pointer to the vertex array", "vertex-array", "glGetPointerv()"),
|
||||
new GLproperty(GL11.GL_VERTEX_ARRAY_SIZE, "GL_VERTEX_ARRAY_SIZE", "Coordinates per vertex", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_VERTEX_ARRAY_STRIDE, "GL_VERTEX_ARRAY_STRIDE", "Stride between vertices", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_VERTEX_ARRAY_TYPE, "GL_VERTEX_ARRAY_TYPE", "Type of vertex coordinates", "vertex-array", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_VIEWPORT, "GL_VIEWPORT", "Viewport origin and extent", "viewport", GL_GET_INTEGERV),
|
||||
new GLproperty(GL11.GL_ZOOM_X, "GL_ZOOM_X", "x zoom factor", "pixel", GL_GET_FLOATV),
|
||||
new GLproperty(GL11.GL_ZOOM_Y, "GL_ZOOM_Y", "y zoom factor", "pixel", GL_GET_FLOATV),
|
||||
};
|
||||
|
||||
public static void dumpToFile(Consumer<Consumer<String>> dumper, String fileName) {
|
||||
final List<String> lines = new ArrayList<>();
|
||||
dumper.accept(lines::add);
|
||||
try {
|
||||
FileUtils.writeLines(new File(fileName), lines);
|
||||
} catch (IOException e) {
|
||||
LOGGER.error("Failed to write file");
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public static void dumpStateToFile() {
|
||||
dumpToFile(p -> dumpState(p, false), "gl-dump-state.txt");
|
||||
}
|
||||
public static void dumpGLSMStateToFile() {
|
||||
dumpToFile(p -> dumpState(p, true), "glsm-dump-state.txt");
|
||||
}
|
||||
|
||||
public static void dumpState(boolean glsm) {
|
||||
dumpState(LINE_LOGGER, glsm);
|
||||
}
|
||||
|
||||
public static void dumpState(Consumer<String> printer, boolean glsm) {
|
||||
for (int i = 0; i < instance.propertyList.length; ++i) {
|
||||
final GLproperty gLproperty = instance.propertyList[i];
|
||||
printer.accept(gLproperty.name + ":" + gLproperty.getAsString(glsm) + " (" + gLproperty.description + ")");
|
||||
}
|
||||
}
|
||||
|
||||
public static void dumpIsEnabledToFile() {
|
||||
dumpToFile(p -> dumpIsEnabled(p, false), "gl-dump-enabled.txt");
|
||||
}
|
||||
|
||||
public static void dumpIsEnabledGLSMToFile() {
|
||||
dumpToFile(p -> dumpIsEnabled(p, true), "gl-dump-enabled.txt");
|
||||
}
|
||||
|
||||
public static void dumpIsEnabled() {
|
||||
dumpIsEnabled(LINE_LOGGER, false);
|
||||
}
|
||||
|
||||
public static void dumpIsEnabledGLSM() {
|
||||
dumpIsEnabled(LINE_LOGGER, true);
|
||||
}
|
||||
|
||||
public static void dumpIsEnabled(Consumer<String> printer, boolean glsm) {
|
||||
for (int i = 0; i < instance.propertyList.length; ++i) {
|
||||
final GLproperty gLProperty = instance.propertyList[i];
|
||||
if (gLProperty.fetchCommand.equals(GL_IS_ENABLED)) {
|
||||
printer.accept(gLProperty.name + ":");
|
||||
printer.accept("" + gLProperty.getAsString(glsm));
|
||||
printer.accept(" (" + gLProperty.description + ")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void dumpTypeToFile(String type, boolean glsm) {
|
||||
dumpToFile(p -> dumpType(type, p, glsm), (glsm ? "glsm" : "gl") + "-dump-type-" + type + ".txt");
|
||||
}
|
||||
|
||||
public static void dumpType(String type, boolean glsm) {
|
||||
dumpType(type, LINE_LOGGER, glsm);
|
||||
}
|
||||
|
||||
public static void dumpType(String type, Consumer<String> printer, boolean glsm) {
|
||||
for (int i = 0; i < instance.propertyList.length; ++i) {
|
||||
final GLproperty gLProperty = instance.propertyList[i];
|
||||
if (gLProperty.category.equals(type)) {
|
||||
printer.accept(gLProperty.name + ":");
|
||||
printer.accept(gLProperty.getAsString(glsm));
|
||||
printer.accept(" (" + gLProperty.description + ")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void checkGLSM() {
|
||||
boolean mismatch = false;
|
||||
for (int i = 0; i < instance.propertyList.length; ++i) {
|
||||
final GLproperty gLProperty = instance.propertyList[i];
|
||||
if(gLProperty.fetchCommand.equals(GL_GET_FLOATV) && gLProperty.name.endsWith("_MATRIX")) {
|
||||
final Matrix4f cached = gLProperty.getAsMatrix4f(true);
|
||||
final Matrix4f uncached = gLProperty.getAsMatrix4f(false);
|
||||
// Some precision issues due to RAD vs degrees, and translated (vs f)
|
||||
if (!cached.equals(uncached, 0.001f)) {
|
||||
LOGGER.error("GLSM mismatch: " + gLProperty.name + "\ncached:\n" + cached + "uncached:\n" + uncached);
|
||||
mismatch = true;
|
||||
}
|
||||
} else {
|
||||
final String cached = gLProperty.getAsString(true);
|
||||
final String uncached = gLProperty.getAsString(false);
|
||||
if (!cached.equals(uncached)) {
|
||||
LOGGER.error("GLSM mismatch: " + gLProperty.name + " cached: " + cached + " uncached: " + uncached);
|
||||
mismatch = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!mismatch) {
|
||||
LOGGER.info("GLSM state matches!");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.joml.Vector3d;
|
||||
|
||||
public class Vector3dStack extends Vector3d implements IStateStack<Vector3dStack> {
|
||||
protected final Vector3d[] stack;
|
||||
|
||||
protected int pointer;
|
||||
|
||||
public Vector3dStack() {
|
||||
stack = new Vector3d[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new Vector3d();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Vector3dStack push() {
|
||||
if(pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
stack[pointer++].set(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Vector3dStack pop() {
|
||||
if(pointer == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
set(stack[--pointer]);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -23,7 +23,7 @@ public class BooleanState implements ISettableState<BooleanState> {
|
||||
}
|
||||
|
||||
public void setEnabled(boolean enabled) {
|
||||
if (GLStateManager.BYPASS_CACHE || enabled != this.enabled) {
|
||||
if (GLStateManager.shouldBypassCache() || enabled != this.enabled) {
|
||||
this.enabled = enabled;
|
||||
if (enabled) {
|
||||
GL11.glEnable(this.glCap);
|
||||
|
||||
@@ -15,12 +15,21 @@ public class MatrixMode implements ISettableState<MatrixMode> {
|
||||
return;
|
||||
}
|
||||
|
||||
if(this.mode != mode || GLStateManager.BYPASS_CACHE) {
|
||||
if(this.mode != mode || GLStateManager.shouldBypassCache()) {
|
||||
this.mode = mode;
|
||||
GL11.glMatrixMode(mode);
|
||||
}
|
||||
}
|
||||
|
||||
public int getMatrix() {
|
||||
return switch(mode) {
|
||||
case GL11.GL_MODELVIEW -> GL11.GL_MODELVIEW_MATRIX;
|
||||
case GL11.GL_PROJECTION -> GL11.GL_PROJECTION_MATRIX;
|
||||
case GL11.GL_TEXTURE -> GL11.GL_TEXTURE_MATRIX;
|
||||
default -> throw new IllegalStateException("Unexpected value: " + mode);
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public MatrixMode set(MatrixMode state) {
|
||||
this.mode = state.mode;
|
||||
|
||||
@@ -3,18 +3,25 @@ package com.gtnewhorizons.angelica.glsm.states;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.TextureBindingStack;
|
||||
import lombok.Getter;
|
||||
import org.joml.Matrix4fStack;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public class TextureUnitArray {
|
||||
private TextureBindingStack[] bindings;
|
||||
private BooleanStateStack[] states;
|
||||
private final TextureBindingStack[] bindings;
|
||||
private final BooleanStateStack[] states;
|
||||
@Getter
|
||||
public final Matrix4fStack[] textureMatricies;
|
||||
|
||||
public TextureUnitArray() {
|
||||
bindings = new TextureBindingStack[GLStateManager.MAX_TEXTURE_UNITS];
|
||||
states = new BooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
|
||||
textureMatricies = new Matrix4fStack[GLStateManager.MAX_TEXTURE_UNITS];
|
||||
|
||||
for (int i = 0; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
|
||||
bindings[i] = new TextureBindingStack();
|
||||
states[i] = new BooleanStateStack(GL11.GL_TEXTURE_2D);
|
||||
textureMatricies[i] = new Matrix4fStack(GLStateManager.MAX_TEXTURE_STACK_DEPTH);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,6 +33,10 @@ public class TextureUnitArray {
|
||||
return states[index];
|
||||
}
|
||||
|
||||
public Matrix4fStack getTextureUnitMatrix(int index) {
|
||||
return textureMatricies[index];
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object state) {
|
||||
if (this == state) return true;
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.interfaces;
|
||||
|
||||
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
|
||||
public interface IThreadSafeISBRH extends ISimpleBlockRenderingHandler {
|
||||
IThreadSafeISBRH getThreadLocal();
|
||||
|
||||
}
|
||||
@@ -20,11 +20,19 @@ public class MixinCompatHackTweaker implements ITweaker {
|
||||
public static final boolean DISABLE_OPTIFINE_AND_FASTCRAFT = true;
|
||||
@Override
|
||||
public void acceptOptions(List<String> args, File gameDir, File assetsDir, String profile) {
|
||||
verifyDependencies();
|
||||
|
||||
if(DISABLE_OPTIFINE_AND_FASTCRAFT) {
|
||||
LOGGER.info("Disabling Optifine and Fastcraft (if present)");
|
||||
disableOptifineAndFastcraft();
|
||||
}
|
||||
}
|
||||
|
||||
private void verifyDependencies() {
|
||||
if(MixinCompatHackTweaker.class.getResource("/it/unimi/dsi/fastutil/ints/Int2ObjectMap.class") == null) {
|
||||
throw new RuntimeException("Missing dependency: Angelica requires GTNHLib 0.2.1 or newer! Download: https://modrinth.com/mod/gtnhlib");
|
||||
}
|
||||
}
|
||||
|
||||
private void disableOptifineAndFastcraft() {
|
||||
// Remove Optifine and Fastcraft transformers & Mod Containers
|
||||
|
||||
@@ -79,6 +79,7 @@ public enum Mixins {
|
||||
,"shaders.startup.MixinInitRenderer"
|
||||
,"shaders.startup.MixinAbstractTexture"
|
||||
,"shaders.startup.MixinTextureAtlasSprite"
|
||||
,"shaders.startup.MixinTextureMap"
|
||||
)
|
||||
),
|
||||
|
||||
|
||||
@@ -12,7 +12,7 @@ public class MixinMinecraft {
|
||||
|
||||
@Inject(
|
||||
method = "runGameLoop",
|
||||
at = @At(value = "INVOKE", target = "Lcpw/mods/fml/common/FMLCommonHandler;onRenderTickEnd(F)V", shift = At.Shift.AFTER)
|
||||
at = @At(value = "INVOKE", target = "Lcpw/mods/fml/common/FMLCommonHandler;onRenderTickEnd(F)V", shift = At.Shift.AFTER, remap = false)
|
||||
)
|
||||
private void angelica$injectLightingFixPostRenderTick(CallbackInfo ci) {
|
||||
GL11.glEnable(GL11.GL_LIGHTING);
|
||||
|
||||
+2
-2
@@ -10,8 +10,8 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
|
||||
@Mixin(BlockFence.class)
|
||||
public abstract class MixinBlockFence extends Block {
|
||||
private MixinBlockFence(Material p_i45394_1_) {
|
||||
super(p_i45394_1_);
|
||||
private MixinBlockFence(Material materialIn) {
|
||||
super(materialIn);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
-5
@@ -13,9 +13,4 @@ public abstract class MixinSplashProgress {
|
||||
GLStateManager.setRunningSplash(true);
|
||||
}
|
||||
|
||||
@Inject(method = "clearGL", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/locks/Lock;unlock()V", shift = At.Shift.BEFORE))
|
||||
private void angelica$endSplash(CallbackInfo ci) {
|
||||
GLStateManager.setRunningSplash(false);
|
||||
}
|
||||
|
||||
}
|
||||
+6
-6
@@ -31,17 +31,17 @@ public abstract class MixinBlockLeaves extends BlockLeavesBase {
|
||||
//A mod dev had no idea what they were doing.
|
||||
return getIcon(side, world.getBlockMetadata(x, y, z));
|
||||
}
|
||||
int renderMode = ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()).ordinal() - 1;
|
||||
int maskedMeta = world.getBlockMetadata(x, y, z) & 3;
|
||||
renderMode = switch (renderMode) {
|
||||
case -1 -> SettingsManager.leavesOpaque ? 1 : 0;
|
||||
case 4 -> world.getBlock(
|
||||
int renderMode;
|
||||
if(Settings.MODE_LEAVES.option.getStore() == LeavesQuality.SHELLED_FAST) {
|
||||
renderMode = world.getBlock(
|
||||
x + Facing.offsetsXForSide[side],
|
||||
y + Facing.offsetsYForSide[side],
|
||||
z + Facing.offsetsZForSide[side]
|
||||
) instanceof ILeafBlock ? 1 : 0;
|
||||
default -> renderMode > 1 ? 0 : renderMode;
|
||||
};
|
||||
} else {
|
||||
renderMode = SettingsManager.leavesOpaque ? 1 : 0;
|
||||
}
|
||||
maskedMeta = maskedMeta >= field_150129_M[renderMode].length ? 0 : maskedMeta;
|
||||
return field_150129_M[renderMode][maskedMeta];
|
||||
}
|
||||
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.shaders.startup;
|
||||
|
||||
import net.coderbot.iris.texture.pbr.PBRAtlasHolder;
|
||||
import net.coderbot.iris.texture.pbr.TextureAtlasExtension;
|
||||
import net.minecraft.client.renderer.texture.AbstractTexture;
|
||||
import net.minecraft.client.renderer.texture.TextureMap;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Unique;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
|
||||
@Mixin(TextureMap.class)
|
||||
public abstract class MixinTextureMap extends AbstractTexture implements TextureAtlasExtension {
|
||||
@Unique
|
||||
private PBRAtlasHolder iris$pbrHolder;
|
||||
|
||||
@Inject(method = "updateAnimations()V", at = @At("TAIL"))
|
||||
private void iris$onTailUpdateAnimations(CallbackInfo ci) {
|
||||
if (iris$pbrHolder != null) {
|
||||
iris$pbrHolder.cycleAnimationFrames();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public PBRAtlasHolder getPBRHolder() {
|
||||
return iris$pbrHolder;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PBRAtlasHolder getOrCreatePBRHolder() {
|
||||
if (iris$pbrHolder == null) {
|
||||
iris$pbrHolder = new PBRAtlasHolder();
|
||||
}
|
||||
return iris$pbrHolder;
|
||||
}
|
||||
}
|
||||
@@ -35,7 +35,7 @@ public class MixinMinecraft {
|
||||
return SodiumClientMod.options().quality.grassQuality.isFancy();
|
||||
}
|
||||
|
||||
@Redirect(method = "checkGLError", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glGetError()I"))
|
||||
@Redirect(method = "checkGLError", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glGetError()I", remap = false))
|
||||
private int sodium$checkGLError() {
|
||||
return SodiumClientMod.options().performance.useNoErrorGLContext ? 0 : GL11.glGetError();
|
||||
}
|
||||
|
||||
+27
-5
@@ -1,21 +1,26 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.sodium;
|
||||
|
||||
import com.gtnewhorizons.angelica.interfaces.IThreadSafeISBRH;
|
||||
import com.gtnewhorizons.angelica.api.ThreadSafeISBRH;
|
||||
import com.gtnewhorizons.angelica.api.ThreadSafeISBRHFactory;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IRenderingRegistryExt;
|
||||
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
|
||||
import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
|
||||
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
import cpw.mods.fml.client.registry.RenderingRegistry;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.Map;
|
||||
|
||||
@Mixin(value = RenderingRegistry.class, remap = false)
|
||||
public class MixinRenderingRegistry implements IRenderingRegistryExt {
|
||||
@Shadow private Map<Integer, ISimpleBlockRenderingHandler> blockRenderers;
|
||||
|
||||
private ThreadLocal<Map<Class<?>, Object>> THREAD_LOCAL_MAP = ThreadLocal.withInitial(Reference2ObjectOpenHashMap::new);
|
||||
@Override
|
||||
public ISimpleBlockRenderingHandler getISBRH(int modelId) {
|
||||
return this.blockRenderers.get(modelId);
|
||||
@@ -23,10 +28,27 @@ public class MixinRenderingRegistry implements IRenderingRegistryExt {
|
||||
|
||||
@WrapOperation(method = { "renderWorldBlock", "renderInventoryBlock", "renderItemAsFull3DBlock" }, at = @At(value="INVOKE", target="Ljava/util/Map;get(Ljava/lang/Object;)Ljava/lang/Object;"))
|
||||
private Object getWrapped(Map<Integer, ISimpleBlockRenderingHandler> instance, Object modelId, Operation<ISimpleBlockRenderingHandler> original) {
|
||||
final ISimpleBlockRenderingHandler res = original.call(instance, modelId);
|
||||
if(res instanceof IThreadSafeISBRH isbhr) {
|
||||
return isbhr.getThreadLocal();
|
||||
// TODO: Move this to BlockRenderer
|
||||
|
||||
// Get the main thread handler
|
||||
final ISimpleBlockRenderingHandler mainThreadHandler = original.call(instance, modelId);
|
||||
if(Thread.currentThread() != GLStateManager.getMainThread()) {
|
||||
ThreadSafeISBRH annotation = mainThreadHandler.getClass().getAnnotation(ThreadSafeISBRH.class);
|
||||
if (annotation != null && annotation.perThread()) {
|
||||
return THREAD_LOCAL_MAP.get().computeIfAbsent(mainThreadHandler.getClass(), k -> {
|
||||
try {
|
||||
// Won't work with non-default constructors, use ThreadSafeISBRHFactory instead
|
||||
return mainThreadHandler.getClass().getDeclaredConstructor().newInstance();
|
||||
} catch (InstantiationException | IllegalAccessException | NoSuchMethodException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch(InvocationTargetException e) {
|
||||
throw new RuntimeException(e.getCause());
|
||||
}
|
||||
});
|
||||
} else if (mainThreadHandler.getClass().isInstance(ThreadSafeISBRHFactory.class)) {
|
||||
return THREAD_LOCAL_MAP.get().computeIfAbsent(mainThreadHandler.getClass(), k -> ((ThreadSafeISBRHFactory) mainThreadHandler).newInstance());
|
||||
}
|
||||
}
|
||||
return res;
|
||||
return mainThreadHandler;
|
||||
}
|
||||
}
|
||||
+6
-6
@@ -20,17 +20,17 @@ public abstract class MixinBlockMagicalLeaves extends Block implements ILeafBloc
|
||||
|
||||
@Override
|
||||
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
|
||||
int renderMode = ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()).ordinal() - 1;
|
||||
int maskedMeta = world.getBlockMetadata(x, y, z) & 3;
|
||||
renderMode = switch (renderMode) {
|
||||
case -1 -> SettingsManager.leavesOpaque ? 1 : 0;
|
||||
case 4 -> world.getBlock(
|
||||
int renderMode;
|
||||
if(Settings.MODE_LEAVES.option.getStore() == LeavesQuality.SHELLED_FAST) {
|
||||
renderMode = world.getBlock(
|
||||
x + Facing.offsetsXForSide[side],
|
||||
y + Facing.offsetsYForSide[side],
|
||||
z + Facing.offsetsZForSide[side]
|
||||
) instanceof ILeafBlock ? 1 : 0;
|
||||
default -> renderMode > 1 ? 0 : renderMode;
|
||||
};
|
||||
} else {
|
||||
renderMode = SettingsManager.leavesOpaque ? 1 : 0;
|
||||
}
|
||||
maskedMeta = maskedMeta > 1 ? 0 : maskedMeta;
|
||||
return icon[renderMode + maskedMeta * 2];
|
||||
}
|
||||
|
||||
+6
-6
@@ -17,17 +17,17 @@ public abstract class MixinBlockTFLeaves extends BlockLeaves {
|
||||
|
||||
@Override
|
||||
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
|
||||
int renderMode = ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()).ordinal() - 1;
|
||||
int maskedMeta = world.getBlockMetadata(x, y, z) & 3;
|
||||
renderMode = switch (renderMode) {
|
||||
case -1 -> SettingsManager.leavesOpaque ? 1 : 0;
|
||||
case 4 -> world.getBlock(
|
||||
int renderMode;
|
||||
if(Settings.MODE_LEAVES.option.getStore() == LeavesQuality.SHELLED_FAST) {
|
||||
renderMode = world.getBlock(
|
||||
x + Facing.offsetsXForSide[side],
|
||||
y + Facing.offsetsYForSide[side],
|
||||
z + Facing.offsetsZForSide[side]
|
||||
) instanceof ILeafBlock ? 1 : 0;
|
||||
default -> renderMode > 1 ? 0 : renderMode;
|
||||
};
|
||||
} else {
|
||||
renderMode = SettingsManager.leavesOpaque ? 1 : 0;
|
||||
}
|
||||
maskedMeta = maskedMeta > 1 ? 0 : maskedMeta;
|
||||
return Blocks.leaves.field_150129_M[renderMode][maskedMeta];
|
||||
}
|
||||
|
||||
+6
-6
@@ -17,16 +17,16 @@ public abstract class MixinBlockTFLeaves3 extends BlockLeaves {
|
||||
|
||||
@Override
|
||||
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
|
||||
int renderMode = ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()).ordinal() - 1;
|
||||
renderMode = switch (renderMode) {
|
||||
case -1 -> SettingsManager.leavesOpaque ? 1 : 0;
|
||||
case 4 -> world.getBlock(
|
||||
int renderMode;
|
||||
if(Settings.MODE_LEAVES.option.getStore() == LeavesQuality.SHELLED_FAST) {
|
||||
renderMode = world.getBlock(
|
||||
x + Facing.offsetsXForSide[side],
|
||||
y + Facing.offsetsYForSide[side],
|
||||
z + Facing.offsetsZForSide[side]
|
||||
) instanceof ILeafBlock ? 1 : 0;
|
||||
default -> renderMode > 1 ? 0 : renderMode;
|
||||
};
|
||||
} else {
|
||||
renderMode = SettingsManager.leavesOpaque ? 1 : 0;
|
||||
}
|
||||
return Blocks.leaves.field_150129_M[renderMode][0];
|
||||
}
|
||||
|
||||
|
||||
+6
-6
@@ -16,17 +16,17 @@ import twilightforest.block.BlockTFMagicLeaves;
|
||||
public abstract class MixinBlockTFMagicLeaves extends BlockLeaves {
|
||||
@Override
|
||||
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
|
||||
int renderMode = ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()).ordinal() - 1;
|
||||
int maskedMeta = world.getBlockMetadata(x, y, z) & 3;
|
||||
renderMode = switch (renderMode) {
|
||||
case -1 -> SettingsManager.leavesOpaque ? 1 : 0;
|
||||
case 4 -> world.getBlock(
|
||||
int renderMode;
|
||||
if(Settings.MODE_LEAVES.option.getStore() == LeavesQuality.SHELLED_FAST) {
|
||||
renderMode = world.getBlock(
|
||||
x + Facing.offsetsXForSide[side],
|
||||
y + Facing.offsetsYForSide[side],
|
||||
z + Facing.offsetsZForSide[side]
|
||||
) instanceof ILeafBlock ? 1 : 0;
|
||||
default -> renderMode > 1 ? 0 : renderMode;
|
||||
};
|
||||
} else {
|
||||
renderMode = SettingsManager.leavesOpaque ? 1 : 0;
|
||||
}
|
||||
maskedMeta = maskedMeta > 1 ? 0 : maskedMeta;
|
||||
return switch (maskedMeta) {
|
||||
case 1 -> renderMode == 1 ? SPR_TRANSLEAVES_OPAQUE : SPR_TRANSLEAVES;
|
||||
|
||||
+6
-6
@@ -28,17 +28,17 @@ public abstract class MixinBlockWitchLeaves extends BlockLeavesBase {
|
||||
|
||||
@Override
|
||||
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
|
||||
int renderMode = ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()).ordinal() - 1;
|
||||
int maskedMeta = world.getBlockMetadata(x, y, z) & 3;
|
||||
renderMode = switch (renderMode) {
|
||||
case -1 -> SettingsManager.leavesOpaque ? 1 : 0;
|
||||
case 4 -> world.getBlock(
|
||||
int renderMode;
|
||||
if(Settings.MODE_LEAVES.option.getStore() == LeavesQuality.SHELLED_FAST) {
|
||||
renderMode = world.getBlock(
|
||||
x + Facing.offsetsXForSide[side],
|
||||
y + Facing.offsetsYForSide[side],
|
||||
z + Facing.offsetsZForSide[side]
|
||||
) instanceof ILeafBlock ? 1 : 0;
|
||||
default -> renderMode > 1 ? 0 : renderMode;
|
||||
};
|
||||
} else {
|
||||
renderMode = SettingsManager.leavesOpaque ? 1 : 0;
|
||||
}
|
||||
maskedMeta = maskedMeta > 1 ? 0 : maskedMeta;
|
||||
return iconsForModes[renderMode][maskedMeta];
|
||||
}
|
||||
|
||||
@@ -3,15 +3,18 @@ package com.gtnewhorizons.angelica.proxy;
|
||||
import com.google.common.base.Objects;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.debug.OpenGLDebugging;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import com.gtnewhorizons.angelica.render.CloudRenderer;
|
||||
import cpw.mods.fml.client.registry.ClientRegistry;
|
||||
import cpw.mods.fml.common.FMLCommonHandler;
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
import cpw.mods.fml.common.eventhandler.EventPriority;
|
||||
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.common.gameevent.InputEvent;
|
||||
import cpw.mods.fml.common.gameevent.TickEvent;
|
||||
import cpw.mods.fml.relauncher.ReflectionHelper;
|
||||
import me.jellysquid.mods.sodium.client.SodiumDebugScreenHandler;
|
||||
@@ -24,6 +27,7 @@ import net.minecraft.client.gui.Gui;
|
||||
import net.minecraft.client.gui.GuiMainMenu;
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraft.client.network.NetHandlerPlayClient;
|
||||
import net.minecraft.client.settings.KeyBinding;
|
||||
import net.minecraft.server.integrated.IntegratedServer;
|
||||
import net.minecraft.util.Direction;
|
||||
import net.minecraft.util.MathHelper;
|
||||
@@ -32,11 +36,15 @@ import net.minecraftforge.client.event.EntityViewRenderEvent;
|
||||
import net.minecraftforge.client.event.GuiOpenEvent;
|
||||
import net.minecraftforge.client.event.RenderGameOverlayEvent;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
import net.minecraftforge.event.world.WorldEvent;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
|
||||
import java.lang.management.ManagementFactory;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
|
||||
public class ClientProxy extends CommonProxy {
|
||||
final Minecraft mc = Minecraft.getMinecraft();
|
||||
|
||||
@@ -46,6 +54,17 @@ public class ClientProxy extends CommonProxy {
|
||||
MinecraftForge.EVENT_BUS.register(this);
|
||||
}
|
||||
|
||||
|
||||
@SubscribeEvent
|
||||
public void worldLoad(WorldEvent.Load event) {
|
||||
if(GLStateManager.isRunningSplash()) {
|
||||
GLStateManager.setRunningSplash(false);
|
||||
LOGGER.info("World loaded - Enabling GLSM Cache");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private static KeyBinding glsmKeyBinding;
|
||||
@Override
|
||||
public void init(FMLInitializationEvent event) {
|
||||
if(AngelicaConfig.enableHudCaching) {
|
||||
@@ -62,6 +81,24 @@ public class ClientProxy extends CommonProxy {
|
||||
FMLCommonHandler.instance().bus().register(Iris.INSTANCE);
|
||||
MinecraftForge.EVENT_BUS.register(Iris.INSTANCE);
|
||||
}
|
||||
|
||||
|
||||
FMLCommonHandler.instance().bus().register(this);
|
||||
MinecraftForge.EVENT_BUS.register(this);
|
||||
|
||||
glsmKeyBinding = new KeyBinding("Print GLSM Debug", Keyboard.KEY_NONE, "Angelica Keybinds");
|
||||
ClientRegistry.registerKeyBinding(glsmKeyBinding);
|
||||
}
|
||||
|
||||
private long lastGLSMCheck = 0;
|
||||
@SubscribeEvent
|
||||
public void onKeypress(TickEvent.ClientTickEvent event) {
|
||||
if(event.phase == TickEvent.Phase.END && glsmKeyBinding.getKeyCode() != 0 && Keyboard.isKeyDown(glsmKeyBinding.getKeyCode())) {
|
||||
if(mc.systemTime - lastGLSMCheck > 500) {
|
||||
lastGLSMCheck = mc.systemTime;
|
||||
OpenGLDebugging.checkGLSM();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -74,7 +111,7 @@ public class ClientProxy extends CommonProxy {
|
||||
ReflectionHelper.setPrivateValue(lotrRendering,null,new ConcurrentHashMap<>(),"cachedNaturalBlocks");
|
||||
}
|
||||
catch (ClassNotFoundException e) {
|
||||
AngelicaTweaker.LOGGER.error("Could net replace LOTR handle render code with thread safe version");
|
||||
LOGGER.error("Could not replace LOTR handle render code with thread safe version");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -174,7 +211,7 @@ public class ClientProxy extends CommonProxy {
|
||||
public void onGuiOpen(GuiOpenEvent event) {
|
||||
if(!event.isCanceled() && event.gui instanceof GuiMainMenu && gameStartTime == -1) {
|
||||
gameStartTime = ManagementFactory.getRuntimeMXBean().getUptime() / 1000f;
|
||||
AngelicaTweaker.LOGGER.info("The game loaded in " + gameStartTime + " seconds.");
|
||||
LOGGER.info("The game loaded in " + gameStartTime + " seconds.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+13
-5
@@ -1,10 +1,10 @@
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import com.gtnewhorizons.angelica.interfaces.IThreadSafeISBRH;
|
||||
import com.gtnewhorizons.angelica.api.ThreadSafeISBRH;
|
||||
import com.gtnewhorizons.angelica.api.ThreadSafeISBRHFactory;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IRenderingRegistryExt;
|
||||
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
import cpw.mods.fml.client.registry.RenderingRegistry;
|
||||
import cpw.mods.fml.common.Loader;
|
||||
import cpw.mods.fml.common.versioning.ComparableVersion;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2BooleanMap;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap;
|
||||
import net.minecraft.block.Block;
|
||||
@@ -39,8 +39,16 @@ public class AngelicaBlockSafetyRegistry {
|
||||
}
|
||||
|
||||
private static boolean populateCanRenderOffThread(Block block, Reference2BooleanMap<Block> map) {
|
||||
@SuppressWarnings("deprecation")
|
||||
final boolean canBeOffThread = map == ISBRH_SAFETY_MAP ? ((IRenderingRegistryExt)RenderingRegistry.instance()).getISBRH(block.getRenderType()) instanceof IThreadSafeISBRH : !(block.getClass().getName().startsWith("gregtech."));
|
||||
final boolean canBeOffThread;
|
||||
if(map == ISBRH_SAFETY_MAP) {
|
||||
@SuppressWarnings("deprecation")
|
||||
final ISimpleBlockRenderingHandler isbrh = ((IRenderingRegistryExt)RenderingRegistry.instance()).getISBRH(block.getRenderType());
|
||||
canBeOffThread = isbrh != null
|
||||
&& (isbrh.getClass().isAnnotationPresent(ThreadSafeISBRH.class)
|
||||
|| isbrh instanceof ThreadSafeISBRHFactory);
|
||||
} else {
|
||||
canBeOffThread = !(block.getClass().getName().startsWith("gregtech."));
|
||||
}
|
||||
|
||||
final long stamp = LOCK.writeLock();
|
||||
|
||||
|
||||
@@ -11,6 +11,7 @@ import java.util.List;
|
||||
|
||||
public class BlockTransformer implements IClassTransformer {
|
||||
public static final String BlockClass = "net/minecraft/block/Block";
|
||||
public static final String BlockPackage = BlockClass.substring(0, BlockClass.lastIndexOf('/') + 1);
|
||||
private static final String BlockClassFriendly = BlockClass.replace('/', '.');
|
||||
public static final List<Pair<String, String>> BlockBoundsFields = ImmutableList.of(
|
||||
Pair.of("minX", "field_149759_B"),
|
||||
|
||||
@@ -61,6 +61,16 @@ public class ClassConstantPoolParser {
|
||||
* for
|
||||
*/
|
||||
public boolean find(byte[] basicClass) {
|
||||
return find(basicClass, false);
|
||||
}
|
||||
/**
|
||||
* Returns true if the constant pool of the class represented by this byte array contains one of the Strings we are looking
|
||||
* for.
|
||||
*
|
||||
* @param prefixes If true, it is enough for a constant pool entry to <i>start</i> with one of our Strings to count as a match -
|
||||
* otherwise, the entire String has to match.
|
||||
*/
|
||||
public boolean find(byte[] basicClass, boolean prefixes) {
|
||||
if (basicClass == null || basicClass.length == 0) {
|
||||
return false;
|
||||
}
|
||||
@@ -92,9 +102,9 @@ public class ClassConstantPoolParser {
|
||||
final int strLen = readUnsignedShort(index + 1, basicClass);
|
||||
size = 3 + strLen;
|
||||
for (byte[] bytes : BYTES_TO_SEARCH) {
|
||||
if (strLen == bytes.length) {
|
||||
if (prefixes ? strLen >= bytes.length : strLen == bytes.length) {
|
||||
boolean found = true;
|
||||
for (int j = index + 3; j < index + 3 + strLen; j++) {
|
||||
for (int j = index + 3; j < index + 3 + bytes.length; j++) {
|
||||
if (basicClass[j] != bytes[j - (index + 3)]) {
|
||||
found = false;
|
||||
break;
|
||||
|
||||
@@ -36,6 +36,7 @@ import java.util.stream.Collectors;
|
||||
|
||||
import static com.gtnewhorizons.angelica.transform.BlockTransformer.BlockBoundsFields;
|
||||
import static com.gtnewhorizons.angelica.transform.BlockTransformer.BlockClass;
|
||||
import static com.gtnewhorizons.angelica.transform.BlockTransformer.BlockPackage;
|
||||
|
||||
/**
|
||||
* This transformer redirects all Tessellator.instance field accesses to go through our TessellatorManager.
|
||||
@@ -63,8 +64,16 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
"startGame", "func_71384_a",
|
||||
"initializeTextures", "func_77474_a"
|
||||
);
|
||||
/** All classes in <tt>net.minecraft.block.*</tt> are the block subclasses save for these. */
|
||||
private static final List<String> VanillaBlockExclusions = Arrays.asList(
|
||||
"net/minecraft/block/IGrowable",
|
||||
"net/minecraft/block/ITileEntityProvider",
|
||||
"net/minecraft/block/BlockEventData",
|
||||
"net/minecraft/block/BlockSourceImpl",
|
||||
"net/minecraft/block/material/"
|
||||
);
|
||||
|
||||
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, TessellatorClass, BlockClass,
|
||||
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, TessellatorClass, BlockPackage,
|
||||
Project);
|
||||
private static final Map<String, Map<String, String>> methodRedirects = new HashMap<>();
|
||||
private static final Map<Integer, String> glCapRedirects = new HashMap<>();
|
||||
@@ -76,7 +85,7 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
);
|
||||
private static int remaps = 0;
|
||||
|
||||
private static final Set<String> blockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
|
||||
private static final Set<String> moddedBlockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
|
||||
// Block owners we *shouldn't* redirect because they shadow one of our fields
|
||||
private static final Set<String> blockOwnerExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>());
|
||||
|
||||
@@ -122,6 +131,7 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
.add("glGetTexParameteri")
|
||||
.add("glIsEnabled")
|
||||
.add("glLoadIdentity")
|
||||
.add("glLoadMatrix")
|
||||
.add("glMatrixMode")
|
||||
.add("glMultMatrix")
|
||||
.add("glNewList")
|
||||
@@ -152,7 +162,22 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
methodRedirects.put(EXTBlendFunc, RedirectMap.newMap().add("glBlendFuncSeparateEXT", "tryBlendFuncSeparate"));
|
||||
methodRedirects.put(ARBMultiTexture, RedirectMap.newMap().add("glActiveTextureARB"));
|
||||
methodRedirects.put(Project, RedirectMap.newMap().add("gluPerspective"));
|
||||
blockSubclasses.add(BlockClass);
|
||||
}
|
||||
|
||||
private boolean isVanillaBlockSubclass(String className) {
|
||||
if(className.startsWith(BlockTransformer.BlockPackage)) {
|
||||
for(String exclusion : VanillaBlockExclusions) {
|
||||
if(className.startsWith(exclusion)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean isBlockSubclass(String className) {
|
||||
return isVanillaBlockSubclass(className) || moddedBlockSubclasses.contains(className);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -167,7 +192,7 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
}
|
||||
}
|
||||
|
||||
if (!cstPoolParser.find(basicClass)) {
|
||||
if (!cstPoolParser.find(basicClass, true)) {
|
||||
return basicClass;
|
||||
}
|
||||
|
||||
@@ -176,19 +201,17 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
cr.accept(cn, 0);
|
||||
|
||||
// Track subclasses of Block
|
||||
if (blockSubclasses.contains(cn.superName)) {
|
||||
blockSubclasses.add(cn.name);
|
||||
if (!isVanillaBlockSubclass(cn.name) && isBlockSubclass(cn.superName)) {
|
||||
moddedBlockSubclasses.add(cn.name);
|
||||
cstPoolParser.addString(cn.name);
|
||||
}
|
||||
|
||||
// Check if this class shadows any fields of the parent class
|
||||
if(blockSubclasses.contains(cn.name)) {
|
||||
if(moddedBlockSubclasses.contains(cn.name)) {
|
||||
// If a superclass shadows, then so do we, because JVM will resolve a reference on our class to that
|
||||
// superclass
|
||||
boolean doWeShadow;
|
||||
if(cn.name.equals(BlockClass)) {
|
||||
doWeShadow = false; // by definition
|
||||
} else if(blockOwnerExclusions.contains(cn.superName)) {
|
||||
if(blockOwnerExclusions.contains(cn.superName)) {
|
||||
doWeShadow = true;
|
||||
} else {
|
||||
// Check if we declare any known field names
|
||||
@@ -274,7 +297,7 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
}
|
||||
}
|
||||
else if ((node.getOpcode() == Opcodes.GETFIELD || node.getOpcode() == Opcodes.PUTFIELD) && node instanceof FieldInsnNode fNode) {
|
||||
if(!blockOwnerExclusions.contains(fNode.owner) && blockSubclasses.contains(fNode.owner) && AngelicaConfig.enableSodium) {
|
||||
if(!blockOwnerExclusions.contains(fNode.owner) && isBlockSubclass(fNode.owner) && AngelicaConfig.enableSodium) {
|
||||
Pair<String, String> fieldToRedirect = null;
|
||||
for(Pair<String, String> blockPairs : BlockBoundsFields) {
|
||||
if(fNode.name.equals(blockPairs.getLeft()) || fNode.name.equals(blockPairs.getRight())) {
|
||||
|
||||
@@ -85,7 +85,7 @@ public class SettingsManager {
|
||||
//Do not re-enable, see MixinBlockLeaves workaround for Angelica/Sodium style menus.
|
||||
//mc.renderGlobal.loadRenderers();
|
||||
LeavesQuality value = (LeavesQuality)Settings.MODE_LEAVES.option.getStore();
|
||||
leavesOpaque = value == LeavesQuality.FANCY || (value == LeavesQuality.DEFAULT && !mc.gameSettings.fancyGraphics);
|
||||
leavesOpaque = value == LeavesQuality.FAST || (value == LeavesQuality.DEFAULT && !mc.gameSettings.fancyGraphics);
|
||||
Blocks.leaves.setGraphicsLevel(!leavesOpaque);
|
||||
Blocks.leaves2.setGraphicsLevel(!leavesOpaque);
|
||||
}
|
||||
|
||||
@@ -32,7 +32,7 @@ public class LeafRenderUtil {
|
||||
}
|
||||
if(otherBlock instanceof ILeafBlock) {
|
||||
switch ((LeavesQuality)Settings.MODE_LEAVES.option.getStore()) {
|
||||
case FANCY, SMART -> {
|
||||
case FAST, SMART -> {
|
||||
return false;
|
||||
}
|
||||
case SHELLED_FANCY, SHELLED_FAST -> {
|
||||
|
||||
@@ -4,6 +4,7 @@ import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import jss.notfine.core.Settings;
|
||||
import jss.notfine.core.SettingsManager;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.ReeseSodiumVideoOptionsScreen;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.OptionFlag;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.OptionGroup;
|
||||
@@ -162,7 +163,8 @@ public class SodiumGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.graphics_quality.tooltip"))
|
||||
.setControl(option -> new CyclingControl<>(option, GraphicsMode.class))
|
||||
.setBinding(
|
||||
(opts, value) -> opts.fancyGraphics = value.isFancy(),
|
||||
(opts, value) -> { opts.fancyGraphics = value.isFancy();
|
||||
SettingsManager.graphicsUpdated(); },
|
||||
opts -> GraphicsMode.fromBoolean(opts.fancyGraphics))
|
||||
.setImpact(OptionImpact.HIGH)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
|
||||
+9
-7
@@ -201,13 +201,15 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
|
||||
if(hasMainThreadBlocks) {
|
||||
// Render the other blocks on the main thread
|
||||
try {
|
||||
CompletableFuture.runAsync(() -> this.performMainBuild(cache, buffers, cancellationSource, bounds, renderData, mainThreadBlocks), AngelicaRenderQueue.executor()).get();
|
||||
} catch(InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
return null;
|
||||
} catch(ExecutionException e) {
|
||||
throw new RuntimeException(e);
|
||||
var future = CompletableFuture.runAsync(() -> this.performMainBuild(cache, buffers, cancellationSource, bounds, renderData, mainThreadBlocks), AngelicaRenderQueue.executor());
|
||||
while(!future.isDone() && !cancellationSource.isCancelled()) {
|
||||
try {
|
||||
future.get();
|
||||
} catch(InterruptedException e) {
|
||||
// go around and check cancellation
|
||||
} catch(ExecutionException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
// Check if cancellation happened during that, so we don't render an incomplete chunk
|
||||
if(cancellationSource.isCancelled()) return null;
|
||||
|
||||
@@ -162,7 +162,7 @@ public class FluidRenderer {
|
||||
} else {
|
||||
sprite = sprites[1];
|
||||
facing = ModelQuadFacing.UNASSIGNED;
|
||||
float dir = (float) Math.atan2(velocity.z, velocity.x) - (1.5707964f);
|
||||
float dir = (float) Math.atan2(velocity.z, velocity.x) - (((float)Math.PI / 2F));
|
||||
float sin = MathHelper.sin(dir) * 0.25F;
|
||||
float cos = MathHelper.cos(dir) * 0.25F;
|
||||
u1 = sprite.getInterpolatedU(8.0F + (-cos - sin) * 16.0F);
|
||||
|
||||
@@ -74,7 +74,10 @@ public class AtlasPBRLoader implements PBRTextureLoader<TextureMap> {
|
||||
}
|
||||
|
||||
if (normalAtlas != null) {
|
||||
if (normalAtlas.tryUpload(atlasWidth, atlasHeight, mipLevel, ((TextureMapAccessor) texMap).getAnisotropicFiltering())) {
|
||||
if (normalAtlas.tryUpload(atlasWidth,
|
||||
atlasHeight,
|
||||
mipLevel,
|
||||
((TextureMapAccessor) texMap).getAnisotropicFiltering())) {
|
||||
pbrTextureConsumer.acceptNormalTexture(normalAtlas);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -47,3 +47,4 @@ public net.minecraft.client.gui.GuiSlot field_148165_u # hasListHeader
|
||||
public net.minecraft.client.gui.GuiSlot field_148161_k # mc
|
||||
public net.minecraft.client.gui.GuiSlot func_148121_k()V # void bindAmountScrolled()
|
||||
public net.minecraft.client.gui.GuiSlot func_148136_c(IIII)V # void overlayBackground()
|
||||
public net.minecraft.client.Minecraft field_71423_H # systemTime
|
||||
Reference in new issue
Block a user