Compare commits

..
Author SHA1 Message Date
Jason Mitchell 8a50ed036d More GLSM Tests (#282)
* Properly Cache GL_SHADE_MODEL and make it a stack

* Add opengl_32_core to docs, so we can easily see what is needed to be deprecated/emulated
Add some stub functions to be fleshed out later
2024-02-11 12:13:51 -08:00
Jason Mitchell f1394382ab Make note of required versions of mods if present 2024-02-11 10:45:20 -08:00
Raven Szewczyk 74e6c80aad A few buildscript and test tweaks (#281)
* Kotlin buildscript for better IDE integration

* Fix transitive Bauble dep, move CoreTweaks to a fake-ivy dependency

* Don't scan fullscreen modes for window creation

* Update GTNHGradle
2024-02-11 05:24:08 -08:00
ah-OOG-ah da9d6bad56 Fix typo in issue template (#280) 2024-02-10 20:57:40 -08:00
Jason Mitchell 58a6fabf3c Enough with the bug reports about disabled features 2024-02-10 20:51:18 -08:00
Jason MitchellandDarren Eberly f8c11967d1 Glsm tests (#275)
* Tests for GL_DEPTH_BUFFER_BIT
* Swizzle DepthState.mask ~> enabled
* Use AssertAll so we can clearly see gl/glsm state differences
* Reset test state leakage from ColorBufferBit
* Add start of test for GL_CURRENT_BIT
* Initial basic display list tests
* Print mismatched array index for array comparisions
* Add message for all tests
* Test GL_CURRENT_BIT
* Implement GLSM stub functions
* Test GL_ENABLE_BIT
* Add verifyNotDefaultState when we don't care about the values, just that they're not the default
* GL_MULTISAMPLE seems to be broken on Nvidia
* Test GL_FOG_BIT
* Check glGetError() after every test
* Exclude some tests based on vendor
* Test most of GL_LIGHTING_BIT

---------

Co-authored-by: Darren Eberly <[email protected]>
2024-02-10 16:51:12 -08:00
Jason Mitchell 6d1c4bf39c Revert "fix release workaround"
This reverts commit 018a47e400.
2024-02-10 09:43:48 -08:00
21 changed files with 1905 additions and 222 deletions

No files matched your search

+1 -1
View File
@@ -62,6 +62,6 @@ body:
required: true
- label: "I am running an officially released version. (Or, if I've compiled it myself I plan to fix the issue)"
required: true
- label: "This issue is not shader related (they aren't ready yet for testing)"
- label: "This issue is not related to a feature that is disabed by default - Shaders, MCPF, etc. [They'll be enabled when they're ready for testing]"
required: true
+1 -1
View File
@@ -10,5 +10,5 @@ permissions:
jobs:
release-tags:
uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@fix-release-tags-for-opengl-testing
uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master
secrets: inherit
+1
View File
@@ -9,6 +9,7 @@
# Required Dependencies
* [UniMixins](https://github.com/LegacyModdingMC/UniMixins/releases) >= 0.1.14
* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.2.1
* NOTE: Some mods are not required, but a specific version is required if present - see: `Permanent Incompatibilities` below.
# Known (temporary) Incompatibilities
* Forge Relocation - Currently non Thread Safe; safe if not in use
-21
View File
@@ -1,21 +0,0 @@
test {
useJUnitPlatform()
testLogging {
events "passed", "skipped", "failed"
}
javaLauncher = javaToolchains.launcherFor {
languageVersion = JavaLanguageVersion.of(8)
}
dependsOn("extractNatives2")
jvmArgs += "-Djava.library.path=${tasks.extractNatives2.destinationFolder.asFile.get().path}"
}
allprojects {
gradle.projectsEvaluated {
tasks.withType(JavaCompile) {
options.compilerArgs << "-Xmaxerrs" << "2000"
}
}
}
-5
View File
@@ -1,5 +0,0 @@
//version: 1707058017
plugins {
id 'com.gtnewhorizons.gtnhconvention'
}
+22
View File
@@ -0,0 +1,22 @@
plugins {
id("com.gtnewhorizons.gtnhconvention")
}
tasks.test {
useJUnitPlatform()
testLogging {
events("passed", "skipped", "failed")
}
javaLauncher = javaToolchains.launcherFor {
languageVersion = JavaLanguageVersion.of(8)
}
dependsOn(tasks.extractNatives2)
jvmArgs("-Djava.library.path=${tasks.extractNatives2.get().destinationFolder.asFile.get().path}")
}
tasks.register<Copy>("copyDependencies") {
group = "Angelica"
description = "Collect dependencies into the testDependencies folder"
from(configurations.default)
into("testDependencies")
}
+2 -7
View File
@@ -71,7 +71,7 @@ dependencies {
// Notfine Deps
compileOnly("thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev")
runtimeOnly("com.github.GTNewHorizons:Baubles:1.0.1.16:dev")
runtimeOnlyNonPublishable("com.github.GTNewHorizons:Baubles:1.0.1.16:dev")
compileOnly("com.github.GTNewHorizons:twilightforest:2.5.1:dev") {transitive = false }
compileOnly(rfg.deobf('curse.maven:witchery-69673:2234410'))
@@ -88,7 +88,7 @@ dependencies {
// HMMMMM
compileOnly(rfg.deobf("curse.maven:journeymap-32274:2367915"))
runtimeOnly(deobf("https://github.com/makamys/CoreTweaks/releases/download/0.3.3.2/CoreTweaks-1.7.10-0.3.3.2+nomixin.jar"))
runtimeOnlyNonPublishable(rfg.deobf("CoreTweaks:CoreTweaks:0.3.3.2"))
// Hodgepodge
transformedMod("net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev")
@@ -100,8 +100,3 @@ dependencies {
testImplementation("org.mockito:mockito-core:3.+")
testImplementation("org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209")
}
task copyDependencies(type: Copy) {
from configurations.default
into 'testDependencies'
}
File diff suppressed because it is too large. Load diff
+18 -1
View File
@@ -5,7 +5,24 @@ repositories {
name = 'mavenpattern'
url = 'https://mvn.falsepattern.com/releases'
content {
includeGroup "com.falsepattern"
includeGroup 'com.falsepattern'
}
}
exclusiveContent {
forRepository {
ivy {
name = 'CoreTweaks releases'
url = 'https://github.com/makamys/CoreTweaks/releases/download/'
patternLayout {
artifact '[revision]/[module]-1.7.10-[revision]+nomixin(-[classifier])(.[ext])'
}
metadataSources {
artifact()
}
}
}
filter {
includeGroup('CoreTweaks')
}
}
mavenLocal()
+1 -1
View File
@@ -16,5 +16,5 @@ pluginManagement {
}
plugins {
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.12'
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.13'
}
@@ -155,7 +155,7 @@ public class Feature {
// Ambient, diffuse, specular, and emissive color for each material
// Ambient, diffuse, and specular color indices for each material
// Specular exponent for each material
// GL_SHADE_MODEL setting
, GLStateManager.shadeModelState // GL_SHADE_MODEL setting
));
attribToFeatures.put(GL11.GL_LINE_BIT, ImmutableSet.of(
// GL_LINE_SMOOTH flag
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.glsm.debug.OpenGLDebugging;
import com.gtnewhorizons.angelica.glsm.stacks.AlphaStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.BlendStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
@@ -87,8 +86,11 @@ public class GLStateManager {
// GLStateManager State Trackers
private static final IntStack attribs = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
protected static final IntegerStateStack activeTextureUnit = new IntegerStateStack();
protected static final IntegerStateStack shadeModelState = new IntegerStateStack();
static {
activeTextureUnit.setValue(0); // GL_TEXTURE0
shadeModelState.setValue(GL11.GL_SMOOTH);
}
@Getter protected static final TextureUnitArray textures = new TextureUnitArray();
@Getter protected static final BlendStateStack blendState = new BlendStateStack();
@@ -117,7 +119,6 @@ public class GLStateManager {
@Getter protected static final ViewPortStateStack viewportState = new ViewPortStateStack();
private static int modelShadeMode;
// Iris Listeners
private static Runnable blendFuncListener = null;
@@ -271,7 +272,7 @@ public class GLStateManager {
case GL11.GL_BLEND -> blendMode.isEnabled();
case GL11.GL_CULL_FACE -> cullState.isEnabled();
case GL11.GL_DEPTH_TEST -> depthTest.isEnabled();
case GL11.GL_DEPTH_WRITEMASK -> depthState.isMask();
case GL11.GL_DEPTH_WRITEMASK -> depthState.isEnabled();
case GL11.GL_FOG -> fogMode.isEnabled();
case GL11.GL_LIGHTING -> lightingState.isEnabled();
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
@@ -314,6 +315,7 @@ public class GLStateManager {
case GL11.GL_DEPTH_FUNC -> depthState.getFunc();
case GL11.GL_LIST_MODE -> glListMode;
case GL11.GL_MATRIX_MODE -> matrixMode.getMode();
case GL11.GL_SHADE_MODEL -> shadeModelState.getValue();
case GL11.GL_TEXTURE_BINDING_2D -> getBoundTexture();
case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
@@ -342,6 +344,10 @@ public class GLStateManager {
}
}
public static void glGetLight(int light, int pname, FloatBuffer params) {
GL11.glGetLight(light, pname, params);
}
public static void glGetFloat(int pname, FloatBuffer params) {
if(shouldBypassCache()) {
GL11.glGetFloat(pname, params);
@@ -370,6 +376,10 @@ public class GLStateManager {
// GLStateManager Functions
public static void glBlendColor(float red, float green, float blue, float alpha) {
GL14.glBlendColor(red, green, blue, alpha);
}
public static void enableBlend() {
if (AngelicaConfig.enableIris) {
if (BlendModeStorage.isBlendLocked()) {
@@ -423,6 +433,14 @@ public class GLStateManager {
if (blendFuncListener != null) blendFuncListener.run();
}
public static void glBlendEquation(int mode) {
GL14.glBlendEquation(mode);
}
public static void glBlendEquationSeparate(int modeRGB, int modeAlpha) {
GL20.glBlendEquationSeparate(modeRGB, modeAlpha);
}
public static void tryBlendFuncSeparate(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
if (AngelicaConfig.enableIris) {
if (BlendModeStorage.isBlendLocked()) {
@@ -447,6 +465,19 @@ public class GLStateManager {
if (blendFuncListener != null) blendFuncListener.run();
}
public static void glNormal3b(byte nx, byte ny, byte nz) {
GL11.glNormal3b(nx, ny, nz);
}
public static void glNormal3d(double nx, double ny, double nz) {
GL11.glNormal3d(nx, ny, nz);
}
public static void glNormal3f(float nx, float ny, float nz) {
GL11.glNormal3f(nx, ny, nz);
}
public static void glNormal3i(int nx, int ny, int nz) {
GL11.glNormal3i(nx, ny, nz);
}
public static void glDepthFunc(int func) {
if (shouldBypassCache() || func != depthState.getFunc() ) {
depthState.setFunc(func);
@@ -462,12 +493,16 @@ public class GLStateManager {
}
}
if (mask != depthState.isMask()) {
depthState.setMask(mask);
if (mask != depthState.isEnabled()) {
depthState.setEnabled(mask);
GL11.glDepthMask(mask);
}
}
public static void glEdgeFlag(boolean flag) {
GL11.glEdgeFlag(flag);
}
public static void glColor4f(float red, float green, float blue, float alpha) {
if (changeColor(red, green, blue, alpha)) {
GL11.glColor4f(red, green, blue, alpha);
@@ -569,6 +604,10 @@ public class GLStateManager {
}
}
public static void glClearDepth(double depth) {
GL11.glClearDepth(depth);
}
// ALPHA
public static void enableAlphaTest() {
if (AngelicaConfig.enableIris) {
@@ -658,6 +697,31 @@ public class GLStateManager {
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels_buffer_offset);
}
public static void glTexCoord1f(float s) {
GL11.glTexCoord1f(s);
}
public static void glTexCoord1d(double s) {
GL11.glTexCoord1d(s);
}
public static void glTexCoord2f(float s, float t) {
GL11.glTexCoord2f(s, t);
}
public static void glTexCoord2d(double s, double t) {
GL11.glTexCoord2d(s, t);
}
public static void glTexCoord3f(float s, float t, float r) {
GL11.glTexCoord3f(s, t, r);
}
public static void glTexCoord3d(double s, double t, double r) {
GL11.glTexCoord3d(s, t, r);
}
public static void glTexCoord4f(float s, float t, float r, float q) {
GL11.glTexCoord4f(s, t, r, q);
}
public static void glTexCoord4d(double s, double t, double r, double q) {
GL11.glTexCoord4d(s, t, r, q);
}
public static void glDeleteTextures(int id) {
onDeleteTexture(id);
@@ -720,6 +784,35 @@ public class GLStateManager {
textures.getTextureUnitStates(textureUnit).disable();
}
public static void glRasterPos2f(float x, float y) {
GL11.glRasterPos2f(x, y);
}
public static void glRasterPos2d(double x, double y) {
GL11.glRasterPos2d(x, y);
}
public static void glRasterPos2i(int x, int y) {
GL11.glRasterPos2i(x, y);
}
public static void glRasterPos3f(float x, float y, float z) {
GL11.glRasterPos3f(x, y, z);
}
public static void glRasterPos3d(double x, double y, double z) {
GL11.glRasterPos3d(x, y, z);
}
public static void glRasterPos3i(int x, int y, int z) {
GL11.glRasterPos3i(x, y, z);
}
public static void glRasterPos4f(float x, float y, float z, float w) {
GL11.glRasterPos4f(x, y, z, w);
}
public static void glRasterPos4d(double x, double y, double z, double w) {
GL11.glRasterPos4d(x, y, z, w);
}
public static void glRasterPos4i(int x, int y, int z, int w) {
GL11.glRasterPos4i(x, y, z, w);
}
public static void setFilter(boolean bilinear, boolean mipmap) {
int i, j;
if (bilinear) {
@@ -739,6 +832,14 @@ public class GLStateManager {
GL11.glDrawArrays(mode, first, count);
}
public static void glDrawBuffer(int mode) {
GL11.glDrawBuffer(mode);
}
public static void glLogicOp(int opcode) {
GL11.glLogicOp(opcode);
}
public static void defaultBlendFunc() {
tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
}
@@ -791,16 +892,20 @@ public class GLStateManager {
public static void glFog(int pname, FloatBuffer param) {
// TODO: Iris Notifier
GL11.glFog(pname, param);
if (pname == GL11.GL_FOG_COLOR) {
final float red = param.get(0);
final float green = param.get(1);
final float blue = param.get(2);
if (HAS_MULTIPLE_SET.contains(pname)) {
GL11.glFog(pname, param);
if (pname == GL11.GL_FOG_COLOR) {
final float red = param.get(0);
final float green = param.get(1);
final float blue = param.get(2);
fogState.getFogColor().set(red, green, blue);
fogState.setFogAlpha(param.get(3));
fogState.getFogColorBuffer().clear();
fogState.getFogColorBuffer().put((FloatBuffer) param.position(0)).flip();
fogState.getFogColor().set(red, green, blue);
fogState.setFogAlpha(param.get(3));
fogState.getFogColorBuffer().clear();
fogState.getFogColorBuffer().put((FloatBuffer) param.position(0)).flip();
}
} else {
GLStateManager.glFogf(pname, param.get(0));
}
}
@@ -858,8 +963,8 @@ public class GLStateManager {
}
public static void glShadeModel(int mode) {
if (shouldBypassCache() || modelShadeMode != mode) {
modelShadeMode = mode;
if (shouldBypassCache() || shadeModelState.getValue() != mode) {
shadeModelState.setValue(mode);
GL11.glShadeModel(mode);
}
}
@@ -953,6 +1058,10 @@ public class GLStateManager {
}
}
public static void glClear(int mask) {
// TODO: Implement
GL11.glClear(mask);
}
public static void glPushAttrib(int mask) {
pushState(mask);
GL11.glPushAttrib(mask);
@@ -1243,4 +1352,30 @@ public class GLStateManager {
default -> GL11.glGetTexLevelParameteri(target, level, pname);
};
}
public static void glLight(int light, int pname, FloatBuffer params) {
GL11.glLight(light, pname, params);
}
public static void glLight(int light, int pname, IntBuffer params) {
GL11.glLight(light, pname, params);
}
public static void glLightModel(int pname, FloatBuffer params) {
GL11.glLightModel(pname, params);
}
public static void glLightModel(int pname, IntBuffer params) {
GL11.glLightModel(pname, params);
}
public static void glLightModelf(int pname, float param) {
GL11.glLightModelf(pname, param);
}
public static void glLightModeli(int pname, int param) {
GL11.glLightModeli(pname, param);
}
public static void glColorMaterial(int face, int mode) {
GL11.glColorMaterial(face, mode);
}
}
@@ -6,12 +6,12 @@ import org.lwjgl.opengl.GL11;
@Getter @Setter
public class DepthState implements ISettableState<DepthState> {
protected boolean mask = true;
protected boolean enabled = true;
protected int func = GL11.GL_LESS;
@Override
public DepthState set(DepthState state) {
this.mask = state.mask;
this.enabled = state.enabled;
this.func = state.func;
return this;
}
@@ -20,7 +20,7 @@ public class DepthState implements ISettableState<DepthState> {
public boolean sameAs(Object state) {
if (this == state) return true;
if (!(state instanceof DepthState depthState)) return false;
return mask == depthState.mask && func == depthState.func;
return enabled == depthState.enabled && func == depthState.func;
}
@Override
public DepthState copy() {
@@ -51,6 +51,7 @@ public class RedirectorTransformer implements IClassTransformer {
private static final String GL11 = "org/lwjgl/opengl/GL11";
private static final String GL13 = "org/lwjgl/opengl/GL13";
private static final String GL14 = "org/lwjgl/opengl/GL14";
private static final String GL20 = "org/lwjgl/opengl/GL20";
private static final String Project = "org/lwjgl/util/glu/Project";
private static final String OpenGlHelper = "net/minecraft/client/renderer/OpenGlHelper";
@@ -104,7 +105,9 @@ public class RedirectorTransformer implements IClassTransformer {
.add("glBindTexture")
.add("glBlendFunc")
.add("glCallList")
.add("glClear")
.add("glClearColor")
.add("glClearDepth")
.add("glColor3b")
.add("glColor3d")
.add("glColor3f")
@@ -114,10 +117,13 @@ public class RedirectorTransformer implements IClassTransformer {
.add("glColor4f")
.add("glColor4ub")
.add("glColorMask")
.add("glColorMaterial")
.add("glDeleteTextures")
.add("glDepthFunc")
.add("glDepthMask")
.add("glDrawArrays")
.add("glDrawBuffer")
.add("glEdgeFlag")
.add("glEndList")
.add("glFog")
.add("glFogf")
@@ -126,36 +132,70 @@ public class RedirectorTransformer implements IClassTransformer {
.add("glGetBoolean")
.add("glGetFloat")
.add("glGetInteger")
.add("glGetLight")
.add("glGetTexLevelParameteri")
.add("glGetTexParameterf")
.add("glGetTexParameteri")
.add("glIsEnabled")
.add("glLight")
.add("glLightModel")
.add("glLightModelf")
.add("glLightModeli")
.add("glLoadIdentity")
.add("glLoadMatrix")
.add("glLogicOp")
.add("glMatrixMode")
.add("glMultMatrix")
.add("glNewList")
.add("glNormal3b")
.add("glNormal3d")
.add("glNormal3f")
.add("glNormal3i")
.add("glOrtho")
.add("glPopAttrib")
.add("glPopMatrix")
.add("glPushAttrib")
.add("glPushMatrix")
.add("glRasterPos2d")
.add("glRasterPos2f")
.add("glRasterPos2i")
.add("glRasterPos3d")
.add("glRasterPos3f")
.add("glRasterPos3i")
.add("glRasterPos4d")
.add("glRasterPos4f")
.add("glRasterPos4i")
.add("glRotated")
.add("glRotatef")
.add("glScaled")
.add("glScalef")
.add("glShadeModel")
.add("glTexCoord1d")
.add("glTexCoord1f")
.add("glTexCoord2d")
.add("glTexCoord2f")
.add("glTexCoord3d")
.add("glTexCoord3f")
.add("glTexCoord4d")
.add("glTexCoord4f")
.add("glTexImage2D")
.add("glTexParameter")
.add("glTexParameterf")
.add("glTexParameteri")
.add("glShadeModel")
.add("glTexImage2D")
.add("glTexParameteri")
.add("glTranslated")
.add("glTranslatef")
.add("glViewport")
);
methodRedirects.put(GL13, RedirectMap.newMap().add("glActiveTexture"));
methodRedirects.put(GL14, RedirectMap.newMap().add("glBlendFuncSeparate", "tryBlendFuncSeparate"));
methodRedirects.put(GL14, RedirectMap.newMap()
.add("glBlendFuncSeparate", "tryBlendFuncSeparate")
.add("glBlendColor")
.add("glBlendEquation")
);
methodRedirects.put(GL20, RedirectMap.newMap()
.add("glBlendEquationSeparate")
);
methodRedirects.put(OpenGlHelper, RedirectMap.newMap()
.add("glBlendFunc", "tryBlendFuncSeparate")
.add("func_148821_a", "tryBlendFuncSeparate"));
@@ -17,7 +17,7 @@ public class DepthColorStorage {
ColorMask colorMask = GLStateManager.getColorMask();
final DepthState depthState = GLStateManager.getDepthState();
originalDepthEnable = depthState.isMask();
originalDepthEnable = depthState.isEnabled();
originalColor = new net.coderbot.iris.gl.blending.ColorMask(colorMask.red, colorMask.green, colorMask.blue, colorMask.alpha);
}
@@ -0,0 +1,69 @@
package com.gtnewhorizons.angelica;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import org.junit.jupiter.api.extension.AfterAllCallback;
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.PixelFormat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.GLOBAL;
public class AngelicaExtension implements BeforeAllCallback, AfterEachCallback, ExtensionContext.Store.CloseableResource {
private static boolean started = false;
private static DisplayMode displayMode;
public static String glVendor;
public static String glRenderer;
public static String glVersion;
public static boolean NVIDIA;
public static boolean AMD;
public static boolean INTEL;
public static boolean MESA;
@Override
public void beforeAll(ExtensionContext context) throws LWJGLException {
if (!started) {
started = true;
displayMode = new DisplayMode(800, 600);
Display.setDisplayModeAndFullscreen(displayMode);
Display.setResizable(false);
Display.setFullscreen(false);
final PixelFormat format = new PixelFormat().withDepthBits(24);
Display.create(format);
// Warm-up State Manager features
GLStateManager.preInit();
context.getRoot().getStore(GLOBAL).put("AngelicaExtension", this);
glVendor = GL11.glGetString(GL11.GL_VENDOR);
glRenderer = GL11.glGetString(GL11.GL_RENDERER);
glVersion = GL11.glGetString(GL11.GL_VERSION);
System.out.println("OpenGL Vendor: " + glVendor);
System.out.println("OpenGL Renderer: " + glRenderer);
System.out.println("OpenGL Version: " + glVersion);
NVIDIA = glVendor.toLowerCase().contains("nvidia");
AMD = glVendor.toLowerCase().contains("ati") || glVendor.toLowerCase().contains("amd");
INTEL = glVendor.toLowerCase().contains("intel");
MESA = glVendor.toLowerCase().contains("mesa");
}
}
@Override
public void close() {
Display.destroy();
}
@Override
public void afterEach(ExtensionContext context) throws Exception {
assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "GL Error");
}
}
@@ -1,161 +0,0 @@
package com.gtnewhorizons.angelica;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL14;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.PixelFormat;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
class GLSM_UnitTest {
private static DisplayMode mode;
@BeforeAll
static void setup() throws LWJGLException {
mode = findDisplayMode(800, 600, Display.getDisplayMode().getBitsPerPixel());
Display.setDisplayModeAndFullscreen(mode);
final PixelFormat format = new PixelFormat().withDepthBits(24);
Display.create(format);
GLStateManager.preInit();
}
@AfterAll
static void cleanup() {
Display.destroy();
}
private static DisplayMode findDisplayMode(int width, int height, int bpp) throws LWJGLException {
final DisplayMode[] modes = Display.getAvailableDisplayModes();
for ( DisplayMode mode : modes ) {
if ( mode.getWidth() == width && mode.getHeight() == height && mode.getBitsPerPixel() >= bpp && mode.getFrequency() <= 60 ) {
return mode;
}
}
return Display.getDesktopDisplayMode();
}
void verifyState(int glCap, boolean expected) {
Stream.of(GLStateManager.glIsEnabled(glCap), GL11.glIsEnabled(glCap)).forEach(b -> assertEquals(expected, b));
}
void verifyState(int glCap, int expected) {
Stream.of(GLStateManager.glGetInteger(glCap), GL11.glGetInteger(glCap)).forEach(i -> assertEquals(expected, i));
}
void verifyState(int glCap, float expected) {
Stream.of(GLStateManager.glGetFloat(glCap), GL11.glGetFloat(glCap)).forEach(f -> assertEquals(expected, f, 0.0001f));
}
void verifyState(int glCap, float[] expected) {
final FloatBuffer glBuffer = BufferUtils.createFloatBuffer(16);
final FloatBuffer glsmBuffer = BufferUtils.createFloatBuffer(16);
GL11.glGetFloat(glCap, glBuffer);
GLStateManager.glGetFloat(glCap, glsmBuffer);
for (int i = 0; i < expected.length; i++) {
assertEquals(expected[i], glBuffer.get(i), 0.0001f, "GL State Mismatch");
assertEquals(expected[i], glsmBuffer.get(i), 0.0001f, "GLSM State Mismatch");
}
}
private void verifyState(int glCap, boolean[] expected) {
final ByteBuffer glBuffer = BufferUtils.createByteBuffer(16);
final ByteBuffer glsmBuffer = BufferUtils.createByteBuffer(16);
GL11.glGetBoolean(glCap, glBuffer);
GLStateManager.glGetBoolean(glCap, glsmBuffer);
for (int i = 0; i < expected.length; i++) {
assertEquals(expected[i] ? GL11.GL_TRUE : GL11.GL_FALSE, glBuffer.get(i), "GL State Mismatch");
assertEquals(expected[i] ? GL11.GL_TRUE : GL11.GL_FALSE, glsmBuffer.get(i), "GLSM State Mismatch");
}
}
@Test
void testPushPopColorBufferBit() {
GLStateManager.glPushAttrib(GL11.GL_COLOR_BUFFER_BIT);
/*
* GL_COLOR_BUFFER_BIT
* GL_ALPHA_TEST enable bit
* Alpha test function and reference value
* GL_BLEND enable bit
* Blending source and destination functions
* Constant blend color
* Blending equation
* GL_DITHER enable bit
* GL_DRAW_BUFFER setting
* GL_COLOR_LOGIC_OP enable bit
* GL_INDEX_LOGIC_OP enable bit
* Logic op function
* Color mode and index mode clear values
* Color mode and index mode writemasks
*/
GLStateManager.enableAlphaTest();
GLStateManager.glAlphaFunc(GL11.GL_NEVER, 1f);
GLStateManager.enableBlend();
GLStateManager.glDisable(GL11.GL_DITHER);
GLStateManager.glEnable(GL11.GL_COLOR_LOGIC_OP);
GLStateManager.glEnable(GL11.GL_INDEX_LOGIC_OP);
GLStateManager.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL14.glBlendColor(1f, 1f, 1f, 1f); // Not currently Implemented in GLSM
GL20.glBlendEquationSeparate(GL14.GL_FUNC_REVERSE_SUBTRACT, GL14.GL_FUNC_REVERSE_SUBTRACT); // Not currently Implemented in GLSM
GL11.glDrawBuffer(GL11.GL_FRONT_AND_BACK); // Not currently Implemented in GLSM
GL11.glLogicOp(GL11.GL_OR);// Not currently Implemented in GLSM
GLStateManager.glColor4f(0.5f, 0.5f, 0.5f, 0.5f); // This should not be reset
GLStateManager.glColorMask(false, false, false, false);
GLStateManager.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
verifyState(GL11.GL_ALPHA_TEST, true);
verifyState(GL11.GL_ALPHA_TEST_FUNC, GL11.GL_NEVER);
verifyState(GL11.GL_ALPHA_TEST_REF, 1f);
verifyState(GL11.GL_BLEND, true);
verifyState(GL11.GL_BLEND_SRC, GL11.GL_SRC_ALPHA);
verifyState(GL11.GL_BLEND_DST, GL11.GL_ONE_MINUS_SRC_ALPHA);
verifyState(GL14.GL_BLEND_COLOR, new float[]{1f, 1f, 1f, 1f});
verifyState(GL14.GL_BLEND_EQUATION, GL14.GL_FUNC_REVERSE_SUBTRACT);
verifyState(GL20.GL_BLEND_EQUATION_ALPHA, GL14.GL_FUNC_REVERSE_SUBTRACT);
verifyState(GL11.GL_DITHER, false);
verifyState(GL11.GL_DRAW_BUFFER, GL11.GL_FRONT_AND_BACK);
verifyState(GL11.GL_COLOR_LOGIC_OP, true);
verifyState(GL11.GL_INDEX_LOGIC_OP, true);
verifyState(GL11.GL_LOGIC_OP_MODE, GL11.GL_OR);
verifyState(GL11.GL_CURRENT_COLOR, new float[]{0.5f, 0.5f, 0.5f, 0.5f});
verifyState(GL11.GL_COLOR_WRITEMASK, new boolean[]{false, false, false, false});
verifyState(GL11.GL_COLOR_CLEAR_VALUE, new float[]{0.5f, 0.5f, 0.5f, 0.5f});
GLStateManager.glPopAttrib();
verifyState(GL11.GL_ALPHA_TEST, false);
verifyState(GL11.GL_ALPHA_TEST_FUNC, GL11.GL_ALWAYS);
verifyState(GL11.GL_ALPHA_TEST_REF, 0f);
verifyState(GL11.GL_BLEND, false);
verifyState(GL11.GL_BLEND_SRC, GL11.GL_ONE);
verifyState(GL11.GL_BLEND_DST, GL11.GL_ZERO);
verifyState(GL14.GL_BLEND_COLOR, new float[]{0f, 0f, 0f, 0f});
verifyState(GL14.GL_BLEND_EQUATION, GL14.GL_FUNC_ADD);
verifyState(GL20.GL_BLEND_EQUATION_ALPHA, GL14.GL_FUNC_ADD);
verifyState(GL11.GL_DITHER, true);
verifyState(GL11.GL_DRAW_BUFFER, GL11.GL_BACK);
verifyState(GL11.GL_COLOR_LOGIC_OP, false);
verifyState(GL11.GL_INDEX_LOGIC_OP, false);
verifyState(GL11.GL_LOGIC_OP_MODE, GL11.GL_COPY);
verifyState(GL11.GL_CURRENT_COLOR, new float[]{0.5f, 0.5f, 0.5f, 0.5f}); // This does not get reset
verifyState(GL11.GL_COLOR_WRITEMASK, new boolean[]{true, true, true, true});
verifyState(GL11.GL_COLOR_CLEAR_VALUE, new float[]{0f, 0f, 0f, 0f});
}
}
@@ -0,0 +1,48 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.AngelicaExtension;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL14;
import org.lwjgl.opengl.GL20;
import static com.gtnewhorizons.angelica.util.GLSMUtil.*;
@ExtendWith(AngelicaExtension.class)
class GLSM_DisplayList_UnitTest {
@Test
void testDisplayListCompileCall() {
verifyState(GL11.GL_LIGHTING, false, "GL_LIGHTING Initial State");
int list = GL11.glGenLists(1);
GLStateManager.glNewList(list, GL11.GL_COMPILE);
GLStateManager.glEnable(GL11.GL_LIGHTING);
GLStateManager.glEndList();
verifyState(GL11.GL_LIGHTING, false, "GL_LIGHTING Post Display List Compile");
GLStateManager.glCallList(list);
verifyState(GL11.GL_LIGHTING, true, "GL_LIGHTING Post Display List Call");
// Reset state that we changed during test
GLStateManager.glDisable(GL11.GL_LIGHTING);
}
@Test
void testDisplayListCompileExecute() {
verifyState(GL11.GL_LIGHTING, false, "GL_LIGHTING Initial State");
int list = GL11.glGenLists(1);
GLStateManager.glNewList(list, GL11.GL_COMPILE_AND_EXECUTE);
GLStateManager.glEnable(GL11.GL_LIGHTING);
GLStateManager.glEndList();
verifyState(GL11.GL_LIGHTING, true, "GL_LIGHTING Post Display List Compile and Execute");
// Reset state that we changed during test
GLStateManager.glDisable(GL11.GL_LIGHTING);
}
}
@@ -0,0 +1,380 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.AngelicaExtension;
import com.gtnewhorizons.angelica.util.GLBit;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import org.lwjgl.opengl.GL13;
import org.lwjgl.opengl.GL14;
import org.lwjgl.opengl.GL20;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyIsEnabled;
import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyLightState;
import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyNotDefaultState;
import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
@ExtendWith(AngelicaExtension.class)
class GLSM_PushPop_UnitTest {
public static final boolean[] BOOLEAN_ARRAY_4_TRUE = { true, true, true, true };
public static final boolean[] BOOLEAN_ARRAY_4_FALSE = { false, false, false, false };
public static final float[] FLOAT_ARRAY_3_001 = { 0f, 0f, 1f };
public static final float[] FLOAT_ARRAY_3_POINT_5 = { 0.5f, 0.5f, 0.5f };
public static final float[] FLOAT_ARRAY_4_0 = { 0f, 0f, 0f, 0f };
public static final float[] FLOAT_ARRAY_4_POINT_5 = { 0.5f, 0.5f, 0.5f, 0.5f };
public static final float[] FLOAT_ARRAY_4_1 = { 1f, 1f, 1f, 1f };
public static final float[] FLOAT_ARRAY_4_1000 = { 1f, 0f, 0f, 0f };
public static final float[] FLOAT_ARRAY_4_0001 = { 0f, 0f, 0f, 1f };
public static final float[] FLOAT_ARRAY_MODEL_AMBIENT_DEFAULT = { 0.2f, 0.2f, 0.2f, 1.0f };
public static final float[] FLOAT_ARRAY_4_0010 = { 0f, 0f, 1f, 0f };
public static final float[] FLOAT_ARRAY_3_1 = { 1f, 1f, 1f };
public static final float[] FLOAT_ARRAY_GL_SPOT_DIRECTION_DEFAULT = { 0f, 0f, -1f };
@Test
void testPushPopColorBufferBit() {
GLStateManager.glPushAttrib(GL11.GL_COLOR_BUFFER_BIT);
/*
* GL_COLOR_BUFFER_BIT
* GL_ALPHA_TEST enable bit
* Alpha test function and reference value
* GL_BLEND enable bit
* Blending source and destination functions
* Constant blend color
* Blending equation
* GL_DITHER enable bit
* GL_DRAW_BUFFER setting
* GL_COLOR_LOGIC_OP enable bit
* GL_INDEX_LOGIC_OP enable bit
* Logic op function
* Color mode and index mode clear values
* Color mode and index mode writemasks
*/
GLStateManager.enableAlphaTest();
GLStateManager.glAlphaFunc(GL11.GL_NEVER, 1f);
GLStateManager.enableBlend();
GLStateManager.glDisable(GL11.GL_DITHER);
GLStateManager.glEnable(GL11.GL_COLOR_LOGIC_OP);
GLStateManager.glEnable(GL11.GL_INDEX_LOGIC_OP);
GLStateManager.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GLStateManager.glBlendColor(1f, 1f, 1f, 1f);
GLStateManager.glBlendEquationSeparate(GL14.GL_FUNC_REVERSE_SUBTRACT, GL14.GL_FUNC_REVERSE_SUBTRACT);
GLStateManager.glDrawBuffer(GL11.GL_FRONT_AND_BACK);
GLStateManager.glLogicOp(GL11.GL_OR);
GLStateManager.glColor4f(0.5f, 0.5f, 0.5f, 0.5f); // This should not be reset
GLStateManager.glColorMask(false, false, false, false);
GLStateManager.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
verifyIsEnabled(GL11.GL_ALPHA_TEST, true, "Alpha Test Enable");
verifyState(GL11.GL_ALPHA_TEST_FUNC, GL11.GL_NEVER, "Alpha Test Function");
verifyState(GL11.GL_ALPHA_TEST_REF, 1f, "Alpha Test Reference");
verifyIsEnabled(GL11.GL_BLEND, true, "Blend Enable");
verifyState(GL11.GL_BLEND_SRC, GL11.GL_SRC_ALPHA, "Blend Source");
verifyState(GL11.GL_BLEND_DST, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination");
verifyState(GL14.GL_BLEND_COLOR, FLOAT_ARRAY_4_1, "Blend Color");
verifyState(GL14.GL_BLEND_EQUATION, GL14.GL_FUNC_REVERSE_SUBTRACT, "Blend Equation");
verifyState(GL20.GL_BLEND_EQUATION_ALPHA, GL14.GL_FUNC_REVERSE_SUBTRACT, "Blend Equation Alpha");
verifyIsEnabled(GL11.GL_DITHER, false, "Dither Enable");
verifyState(GL11.GL_DRAW_BUFFER, GL11.GL_FRONT_AND_BACK, "Draw Buffer");
verifyIsEnabled(GL11.GL_COLOR_LOGIC_OP, true, "Color Logic Op Enable");
verifyIsEnabled(GL11.GL_INDEX_LOGIC_OP, true, "Index Logic Op Enable");
verifyState(GL11.GL_LOGIC_OP_MODE, GL11.GL_OR, "Logic Op Mode");
verifyState(GL11.GL_CURRENT_COLOR, FLOAT_ARRAY_4_POINT_5, "Current Color");
verifyState(GL11.GL_COLOR_WRITEMASK, BOOLEAN_ARRAY_4_FALSE, "Color Write Mask");
verifyState(GL11.GL_COLOR_CLEAR_VALUE, FLOAT_ARRAY_4_POINT_5, "Color Clear Value");
GLStateManager.glPopAttrib();
verifyIsEnabled(GL11.GL_ALPHA_TEST, false, "Alpha Test Enable - Reset");
verifyState(GL11.GL_ALPHA_TEST_FUNC, GL11.GL_ALWAYS, "Alpha Test Function - Reset");
verifyState(GL11.GL_ALPHA_TEST_REF, 0f, "Alpha Test Reference - Reset");
verifyIsEnabled(GL11.GL_BLEND, false, "Blend Enable - Reset");
verifyState(GL11.GL_BLEND_SRC, GL11.GL_ONE, "Blend Source - Reset");
verifyState(GL11.GL_BLEND_DST, GL11.GL_ZERO, "Blend Destination - Reset");
verifyState(GL14.GL_BLEND_COLOR, FLOAT_ARRAY_4_0, "Blend Color - Reset");
verifyState(GL14.GL_BLEND_EQUATION, GL14.GL_FUNC_ADD, "Blend Equation - Reset");
verifyState(GL20.GL_BLEND_EQUATION_ALPHA, GL14.GL_FUNC_ADD, "Blend Equation Alpha - Reset");
verifyIsEnabled(GL11.GL_DITHER, true, "Dither Enable - Reset");
verifyState(GL11.GL_DRAW_BUFFER, GL11.GL_BACK, "Draw Buffer - Reset");
verifyIsEnabled(GL11.GL_COLOR_LOGIC_OP, false, "Color Logic Op Enable - Reset");
verifyIsEnabled(GL11.GL_INDEX_LOGIC_OP, false, "Index Logic Op Enable - Reset");
verifyState(GL11.GL_LOGIC_OP_MODE, GL11.GL_COPY, "Logic Op Mode - Reset");
verifyState(GL11.GL_CURRENT_COLOR, FLOAT_ARRAY_4_POINT_5, "Current Color - (Not) Reset"); // This does not get reset
verifyState(GL11.GL_COLOR_WRITEMASK, BOOLEAN_ARRAY_4_TRUE, "Color Write Mask - Reset");
verifyState(GL11.GL_COLOR_CLEAR_VALUE, FLOAT_ARRAY_4_0, "Color Clear Value - Reset");
// Reset State
GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
@Test
void testPushPopCurrentBit() {
verifyState(GL11.GL_CURRENT_COLOR, FLOAT_ARRAY_4_1, "Initial Color State"); // Verify no state leakage from other tests
verifyState(GL11.GL_CURRENT_INDEX, 1, "Initial Index State");
verifyState(GL11.GL_CURRENT_TEXTURE_COORDS, FLOAT_ARRAY_4_0001, "Initial Texture Coordinates");
verifyState(GL11.GL_CURRENT_RASTER_POSITION, FLOAT_ARRAY_4_0001, "Initial Raster Position");
verifyState(GL11.GL_CURRENT_RASTER_POSITION_VALID, true, "Initial Raster Position Valid");
verifyState(GL11.GL_CURRENT_RASTER_COLOR, FLOAT_ARRAY_4_1, "Initial Raster Color");
verifyState(GL11.GL_CURRENT_RASTER_INDEX, 1, "Initial Raster Index");
verifyState(GL11.GL_CURRENT_RASTER_TEXTURE_COORDS, FLOAT_ARRAY_4_0001, "Initial Raster Texture Coordinates");
GLStateManager.glPushAttrib(GL11.GL_CURRENT_BIT);
GLStateManager.glColor4f(0.5f, 0.5f, 0.5f, 0.5f);
// Apparently glIndex is not implemented in lwjgl2?
GLStateManager.glNormal3f(0.5f, 0.5f, 0.5f);
GLStateManager.glTexCoord4f(0.5f, 0.5f, 0.5f, 0.5f); // Current texture coordinates
GLStateManager.glRasterPos4f(0.5f, 0.5f, 0.5f, 0.5f); // Current raster position
// GL_CURRENT_RASTER_POSITION_VALID flag
// RGBA color associated with current raster position
// Color index associated with current raster position
// Texture coordinates associated with current raster position
GLStateManager.glEdgeFlag(false); // GL_EDGE_FLAG flag
verifyState(GL11.GL_CURRENT_COLOR, FLOAT_ARRAY_4_POINT_5, "Current Color");
verifyState(GL11.GL_CURRENT_INDEX, 1f, "Current Index");
verifyState(GL11.GL_CURRENT_NORMAL, FLOAT_ARRAY_3_POINT_5, "Current Normal");
verifyState(GL11.GL_CURRENT_TEXTURE_COORDS, FLOAT_ARRAY_4_POINT_5, "Texture coordinates");
verifyNotDefaultState(GL11.GL_CURRENT_RASTER_POSITION, FLOAT_ARRAY_4_0001, "Raster Position");
verifyState(GL11.GL_CURRENT_RASTER_POSITION_VALID, true, "Raster Position Valid");
verifyState(GL11.GL_CURRENT_RASTER_COLOR, FLOAT_ARRAY_4_POINT_5, "Raster Color");
verifyState(GL11.GL_CURRENT_RASTER_INDEX, 1, "Raster Index");
verifyState(GL11.GL_CURRENT_RASTER_TEXTURE_COORDS, FLOAT_ARRAY_4_POINT_5, "Raster Texture Coordinates");
verifyState(GL11.GL_EDGE_FLAG, false, "Edge Flag");
GLStateManager.glPopAttrib();
verifyState(GL11.GL_CURRENT_COLOR, FLOAT_ARRAY_4_1, "Current Color - reset");
verifyState(GL11.GL_CURRENT_INDEX, 1, "Current Index - reset");
verifyState(GL11.GL_CURRENT_NORMAL, FLOAT_ARRAY_3_001, "Current normal - reset");
verifyState(GL11.GL_CURRENT_TEXTURE_COORDS, FLOAT_ARRAY_4_0001, "Texture coordinates - reset");
verifyState(GL11.GL_CURRENT_RASTER_POSITION, FLOAT_ARRAY_4_0001, "Raster Position - reset");
verifyState(GL11.GL_CURRENT_RASTER_POSITION_VALID, true, "Raster Position Valid - reset");
verifyState(GL11.GL_CURRENT_RASTER_COLOR, FLOAT_ARRAY_4_1, "Raster Color - reset");
verifyState(GL11.GL_CURRENT_RASTER_INDEX, 1, "Raster Index - reset");
verifyState(GL11.GL_CURRENT_RASTER_TEXTURE_COORDS, FLOAT_ARRAY_4_0001, "Raster Texture Coordinates - reset");
verifyState(GL11.GL_EDGE_FLAG, true, "Edge Flag - reset");
}
@Test
void testPushPopDepthBufferBit() {
verifyState(GL11.GL_DEPTH_WRITEMASK, true, "GL_DEPTH_WRITEMASK Initial State");
GLStateManager.glPushAttrib(GL11.GL_DEPTH_BUFFER_BIT);
GLStateManager.glEnable(GL11.GL_DEPTH_TEST);
GLStateManager.glDepthFunc(GL11.GL_NEVER);
GLStateManager.glClearDepth(0.5f); // Not currently Implemented in GLSM
GLStateManager.glDepthMask(false);
verifyState(GL11.GL_DEPTH_TEST, true, "Depth Test");
verifyState(GL11.GL_DEPTH_FUNC, GL11.GL_NEVER, "Depth Function");
verifyState(GL11.GL_DEPTH_CLEAR_VALUE, 0.5f, "Depth Clear Value");
verifyState(GL11.GL_DEPTH_WRITEMASK, false, "Depth Write Mask");
GLStateManager.glPopAttrib();
verifyState(GL11.GL_DEPTH_TEST, false, "Depth Test - Reset");
verifyState(GL11.GL_DEPTH_FUNC, GL11.GL_LESS, "Depth Function - Reset");
verifyState(GL11.GL_DEPTH_CLEAR_VALUE, 1f, "Depth Clear Value - Reset");
verifyState(GL11.GL_DEPTH_WRITEMASK, true, "Depth Write Mask - Reset");
}
@Test
void testPushPopEnableBit() {
final ArrayList<GLBit> bits = new ArrayList<>();
int i;
bits.add(new GLBit(GL11.GL_ALPHA_TEST, "Alpha Test", false));
bits.add(new GLBit(GL11.GL_AUTO_NORMAL, "Auto Normal", false));
bits.add(new GLBit(GL11.GL_BLEND, "Blend", false));
for(i = 0 ; i < GL11.glGetInteger(GL11.GL_MAX_CLIP_PLANES) ; i++) {
bits.add(new GLBit(GL11.GL_CLIP_PLANE0 + i, "Clip Plane " + i, false));
}
bits.add(new GLBit(GL11.GL_COLOR_MATERIAL, "Color Material", false));
bits.add(new GLBit(GL11.GL_CULL_FACE, "Cull Face", false));
bits.add(new GLBit(GL11.GL_DEPTH_TEST, "Depth Test", false));
bits.add(new GLBit(GL11.GL_DITHER, "Dither", true));
bits.add(new GLBit(GL11.GL_FOG, "Fog", false));
// This fails on the RESET test in xvfb
if(!AngelicaExtension.MESA) {
for(i = 0 ; i < GL11.glGetInteger(GL11.GL_MAX_LIGHTS) ; i++) {
bits.add(new GLBit(GL11.GL_LIGHT0 + i, "Light " + i, false));
}
}
bits.add(new GLBit(GL11.GL_LIGHTING, "Lighting", false));
bits.add(new GLBit(GL11.GL_LINE_SMOOTH, "Line Smooth", false));
bits.add(new GLBit(GL11.GL_LINE_STIPPLE, "Line Stipple", false));
bits.add(new GLBit(GL11.GL_COLOR_LOGIC_OP, "Color Logic Op", false));
bits.add(new GLBit(GL11.GL_INDEX_LOGIC_OP, "Index Logic Op", false))
;
bits.add(new GLBit(GL11.GL_MAP1_VERTEX_3, "Map1 Vertex 3", false));
bits.add(new GLBit(GL11.GL_MAP1_VERTEX_4, "Map1 Vertex 4", false));
bits.add(new GLBit(GL11.GL_MAP1_INDEX, "Map1 Index", false));
bits.add(new GLBit(GL11.GL_MAP1_COLOR_4, "Map1 Color 4", false));
bits.add(new GLBit(GL11.GL_MAP1_NORMAL, "Map1 Normal", false));
bits.add(new GLBit(GL11.GL_MAP1_TEXTURE_COORD_1, "Map1 Texture Coord 1", false));
bits.add(new GLBit(GL11.GL_MAP1_TEXTURE_COORD_2, "Map1 Texture Coord 2", false));
bits.add(new GLBit(GL11.GL_MAP1_TEXTURE_COORD_3, "Map1 Texture Coord 3", false));
bits.add(new GLBit(GL11.GL_MAP1_TEXTURE_COORD_4, "Map1 Texture Coord 4", false));
bits.add(new GLBit(GL11.GL_MAP2_VERTEX_3, "Map2 Vertex 3", false));
bits.add(new GLBit(GL11.GL_MAP2_VERTEX_4, "Map2 Vertex 4", false));
bits.add(new GLBit(GL11.GL_MAP2_INDEX, "Map2 Index", false));
bits.add(new GLBit(GL11.GL_MAP2_COLOR_4, "Map2 Color 4", false));
bits.add(new GLBit(GL11.GL_MAP2_NORMAL, "Map2 Normal", false));
bits.add(new GLBit(GL11.GL_MAP2_TEXTURE_COORD_1, "Map2 Texture Coord 1", false));
bits.add(new GLBit(GL11.GL_MAP2_TEXTURE_COORD_2, "Map2 Texture Coord 2", false));
bits.add(new GLBit(GL11.GL_MAP2_TEXTURE_COORD_3, "Map2 Texture Coord 3", false));
bits.add(new GLBit(GL11.GL_MAP2_TEXTURE_COORD_4, "Map2 Texture Coord 4", false));
// Seems to be broken at least on Nvidia
if(!AngelicaExtension.NVIDIA) bits.add(new GLBit(GL13.GL_MULTISAMPLE, "Multisample", true));
bits.add(new GLBit(GL11.GL_NORMALIZE, "Normalize", false));
bits.add(new GLBit(GL11.GL_POINT_SMOOTH, "Point Smooth", false));
bits.add(new GLBit(GL11.GL_POLYGON_OFFSET_LINE, "Polygon Offset Line", false));
bits.add(new GLBit(GL11.GL_POLYGON_OFFSET_FILL, "Polygon Offset Fill", false));
bits.add(new GLBit(GL11.GL_POLYGON_OFFSET_POINT, "Polygon Offset Point", false));
bits.add(new GLBit(GL11.GL_POLYGON_SMOOTH, "Polygon Smooth", false));
bits.add(new GLBit(GL11.GL_POLYGON_STIPPLE, "Polygon Stipple", false));
bits.add(new GLBit(GL13.GL_SAMPLE_ALPHA_TO_COVERAGE, "Sample Alpha To Coverage", false));
bits.add(new GLBit(GL13.GL_SAMPLE_ALPHA_TO_ONE, "Sample Alpha To One", false));
bits.add(new GLBit(GL13.GL_SAMPLE_COVERAGE, "Sample Coverage", false));
bits.add(new GLBit(GL11.GL_SCISSOR_TEST, "Scissor Test", false));
bits.add(new GLBit(GL11.GL_STENCIL_TEST, "Stencil Test", false));
bits.add(new GLBit(GL11.GL_TEXTURE_1D, "Texture 1D", false));
bits.add(new GLBit(GL11.GL_TEXTURE_2D, "Texture 2D", false));
bits.add(new GLBit(GL12.GL_TEXTURE_3D, "Texture 3D", false));
bits.add(new GLBit(GL11.GL_TEXTURE_GEN_S, "Texture Gen S", false));
bits.add(new GLBit(GL11.GL_TEXTURE_GEN_T, "Texture Gen T", false));
bits.add(new GLBit(GL11.GL_TEXTURE_GEN_R, "Texture Gen R", false));
bits.add(new GLBit(GL11.GL_TEXTURE_GEN_Q, "Texture Gen Q", false));
GLStateManager.glPushAttrib(GL11.GL_ENABLE_BIT);
bits.forEach(bit -> {
verifyState(bit.glEnum(), bit.initial(), bit.name() + " Initial State");
if(bit.initial()) {
GLStateManager.glDisable(bit.glEnum());
} else {
GLStateManager.glEnable(bit.glEnum());
}
verifyState(bit.glEnum(), !bit.initial(), bit.name() + " Toggle State");
});
GLStateManager.glPopAttrib();
bits.forEach(bit -> verifyState(bit.glEnum(), bit.initial(), bit.name() + " Reset State"));
}
@Test
void testPushPopFogBit() {
final FloatBuffer floatBuffer = BufferUtils.createFloatBuffer(16);
GLStateManager.glPushAttrib(GL11.GL_FOG_BIT);
GLStateManager.glEnable(GL11.GL_FOG);
floatBuffer.put(FLOAT_ARRAY_4_POINT_5).flip();
GLStateManager.glFog(GL11.GL_FOG_COLOR, floatBuffer);
GLStateManager.glFogf(GL11.GL_FOG_DENSITY, 0.5f);
GLStateManager.glFogf(GL11.GL_FOG_END, 0.5f);
GLStateManager.glFogf(GL11.GL_FOG_START, 0.5f);
GLStateManager.glFogf(GL11.GL_FOG_MODE, GL11.GL_LINEAR);
if(!AngelicaExtension.NVIDIA) GLStateManager.glFogf(GL11.GL_FOG_INDEX, 1f);
verifyIsEnabled(GL11.GL_FOG, true, "Fog Enable");
verifyState(GL11.GL_FOG_COLOR, FLOAT_ARRAY_4_POINT_5, "Fog Color");
verifyState(GL11.GL_FOG_DENSITY, 0.5f, "Fog Density");
verifyState(GL11.GL_FOG_END, 0.5f, "Fog End");
verifyState(GL11.GL_FOG_START, 0.5f, "Fog Start");
verifyState(GL11.GL_FOG_MODE, GL11.GL_LINEAR, "Fog Mode");
if(!AngelicaExtension.NVIDIA) verifyState(GL11.GL_FOG_INDEX, 1f, "Fog Index");
GLStateManager.glPopAttrib();
verifyIsEnabled(GL11.GL_FOG, false, "Fog Enable - Reset");
verifyState(GL11.GL_FOG_COLOR, FLOAT_ARRAY_4_0, "Fog Color - Reset");
verifyState(GL11.GL_FOG_DENSITY, 1f, "Fog Density - Reset");
verifyState(GL11.GL_FOG_END, 1f, "Fog End - Reset");
verifyState(GL11.GL_FOG_START, 0f, "Fog Start - Reset");
verifyState(GL11.GL_FOG_MODE, GL11.GL_EXP, "Fog Mode - Reset");
if(!AngelicaExtension.NVIDIA) verifyState(GL11.GL_FOG_INDEX, 0f, "Fog Index - Reset");
}
@Test
void testPushPopLightingBit() {
final ArrayList<GLBit> bits = new ArrayList<>();
final FloatBuffer floatBuffer = BufferUtils.createFloatBuffer(16);
bits.add(new GLBit(GL11.GL_COLOR_MATERIAL, "Color Material", false));
bits.add(new GLBit(GL11.GL_LIGHTING, "Lighting", false));
for(int i = 0 ; i < GL11.glGetInteger(GL11.GL_MAX_LIGHTS) ; i++) {
bits.add(new GLBit(GL11.GL_LIGHT0 + i, "Light " + i, false));
}
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
GLStateManager.glColorMaterial(GL11.GL_FRONT, GL11.GL_AMBIENT);
// Ambient scene color ??
GLStateManager.glLightModelf(GL11.GL_LIGHT_MODEL_LOCAL_VIEWER, 1f);
GLStateManager.glLightModelf(GL11.GL_LIGHT_MODEL_TWO_SIDE, 1f);
floatBuffer.put(FLOAT_ARRAY_4_POINT_5).flip();
GLStateManager.glLightModel(GL11.GL_LIGHT_MODEL_AMBIENT, floatBuffer);
GLStateManager.glLightModeli(GL12.GL_LIGHT_MODEL_COLOR_CONTROL, GL12.GL_SEPARATE_SPECULAR_COLOR);
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_AMBIENT, floatBuffer);
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, floatBuffer);
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPECULAR, floatBuffer);
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_POSITION, floatBuffer);
floatBuffer.put(FLOAT_ARRAY_4_0010).flip();
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, floatBuffer);
floatBuffer.put(FLOAT_ARRAY_4_0).flip();
GLStateManager.glShadeModel(GL11.GL_FLAT);
verifyState(GL11.GL_COLOR_MATERIAL_FACE, GL11.GL_FRONT, "Color Material Face");
verifyState(GL11.GL_COLOR_MATERIAL_PARAMETER, GL11.GL_AMBIENT, "Color Material Parameter");
verifyState(GL11.GL_LIGHT_MODEL_LOCAL_VIEWER, 1f, "Light Model Local Viewer");
verifyState(GL11.GL_LIGHT_MODEL_TWO_SIDE, 1f, "Light Model Two Side");
verifyState(GL11.GL_LIGHT_MODEL_AMBIENT, FLOAT_ARRAY_4_POINT_5, "Light Model Ambient");
verifyState(GL12.GL_LIGHT_MODEL_COLOR_CONTROL, GL12.GL_SEPARATE_SPECULAR_COLOR, "Light Model Color Control");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_AMBIENT, FLOAT_ARRAY_4_POINT_5, "Light Ambient");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, FLOAT_ARRAY_4_POINT_5, "Light Diffuse");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPECULAR, FLOAT_ARRAY_4_POINT_5, "Light Specular");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_POSITION, FLOAT_ARRAY_4_POINT_5, "Light Position");
verifyState(GL11.GL_SHADE_MODEL, GL11.GL_FLAT, "Shade Model");
bits.forEach(bit -> {
verifyState(bit.glEnum(), bit.initial(), bit.name() + " Initial State");
if(bit.initial()) {
GLStateManager.glDisable(bit.glEnum());
} else {
GLStateManager.glEnable(bit.glEnum());
}
verifyState(bit.glEnum(), !bit.initial(), bit.name() + " Toggle State");
});
GLStateManager.glPopAttrib();
verifyState(GL11.GL_COLOR_MATERIAL_FACE, GL11.GL_FRONT_AND_BACK, "Color Material Face - Reset");
verifyState(GL11.GL_COLOR_MATERIAL_PARAMETER, GL11.GL_AMBIENT_AND_DIFFUSE, "Color Material Parameter - Reset");
verifyState(GL11.GL_LIGHT_MODEL_LOCAL_VIEWER, 0f, "Light Model Local Viewer - Reset");
verifyState(GL11.GL_LIGHT_MODEL_TWO_SIDE, 0f, "Light Model Two Side - Reset");
verifyState(GL11.GL_LIGHT_MODEL_AMBIENT, FLOAT_ARRAY_MODEL_AMBIENT_DEFAULT, "Light Model Ambient - Reset");
verifyState(GL12.GL_LIGHT_MODEL_COLOR_CONTROL, GL12.GL_SINGLE_COLOR, "Light Model Color Control - Reset");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_AMBIENT, FLOAT_ARRAY_4_0001, "Light Ambient - Reset");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, FLOAT_ARRAY_4_1, "Light Diffuse - Reset");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPECULAR, FLOAT_ARRAY_4_1, "Light Specular - Reset");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_POSITION, FLOAT_ARRAY_4_0010, "Light Position - Reset");
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, FLOAT_ARRAY_GL_SPOT_DIRECTION_DEFAULT, "Light Spot Direction - Reset");
verifyState(GL11.GL_SHADE_MODEL, GL11.GL_SMOOTH, "Shade Model - Reset");
bits.forEach(bit -> verifyState(bit.glEnum(), bit.initial(), bit.name() + " Reset State"));
}
}
@@ -0,0 +1,41 @@
package com.gtnewhorizons.angelica.util;
import java.util.Objects;
public final class GLBit {
private final int glEnum;
private final String name;
private final boolean initial;
public GLBit(int glEnum, String name, boolean initial) {
this.name = name;
this.glEnum = glEnum;
this.initial = initial;
}
public String name() {return name;}
public int glEnum() {return glEnum;}
public boolean initial() {return initial;}
@Override
public boolean equals(Object obj) {
if (obj == this) return true;
if (obj == null || obj.getClass() != this.getClass()) return false;
var that = (GLBit) obj;
return Objects.equals(this.name, that.name) && this.glEnum == that.glEnum && this.initial == that.initial;
}
@Override
public int hashCode() {
return Objects.hash(name, glEnum, initial);
}
@Override
public String toString() {
return "GLBit[" + "name=" + name + ", " + "glEnum=" + glEnum + ", " + "initial=" + initial + ']';
}
}
@@ -0,0 +1,110 @@
package com.gtnewhorizons.angelica.util;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.util.stream.IntStream;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
public class GLSMUtil {
public static void verifyIsEnabled(int glCap, boolean expected) {
verifyIsEnabled(glCap, expected, "Is Enabled Mismatch");
}
public static void verifyIsEnabled(int glCap, boolean expected, String message) {
assertAll( message,
() -> assertEquals(expected, GL11.glIsEnabled(glCap), "GL State Mismatch"),
() -> assertEquals(expected, GLStateManager.glIsEnabled(glCap), "GLSM State Mismatch")
);
}
public static void verifyState(int glCap, boolean expected) {
verifyState(glCap, expected, "Boolean State Mismatch");
}
public static void verifyState(int glCap, boolean expected, String message) {
assertAll( message,
() -> assertEquals(expected, GL11.glGetBoolean(glCap), "GL State Mismatch"),
() -> assertEquals(expected, GLStateManager.glGetBoolean(glCap), "GLSM State Mismatch")
);
}
public static void verifyState(int glCap, int expected) {
verifyState(glCap, expected, "Int State Mismatch");
}
public static void verifyState(int glCap, int expected, String message) {
assertAll(message,
() -> assertEquals(expected, GL11.glGetInteger(glCap), "GL State Mismatch"),
() -> assertEquals(expected, GLStateManager.glGetInteger(glCap), "GLSM State Mismatch")
);
}
public static void verifyState(int glCap, float expected) {
verifyState(glCap, expected, "Float State Mismatch");
}
public static void verifyState(int glCap, float expected, String message) {
assertAll(message,
() -> assertEquals(expected, GL11.glGetFloat(glCap), 0.0001f, "GL State Mismatch"),
() -> assertEquals(expected, GLStateManager.glGetFloat(glCap), 0.0001f, "GLSM State Mismatch")
);
}
public static void verifyState(int glCap, float[] expected) {
verifyState(glCap, expected, "Float State Mismatch");
}
static final FloatBuffer glFloatBuffer = BufferUtils.createFloatBuffer(16);
static final FloatBuffer glsmFloatBuffer = BufferUtils.createFloatBuffer(16);
public static void verifyState(int glCap, float[] expected, String message) {
GL11.glGetFloat(glCap, (FloatBuffer) glFloatBuffer.clear());
GLStateManager.glGetFloat(glCap, (FloatBuffer) glsmFloatBuffer.clear());
IntStream.range (0, expected.length).forEach(i -> assertAll(message,
() -> assertEquals(expected[i], glFloatBuffer.get(i), 0.0001f, "GL State Mismatch: " + i),
() -> assertEquals(expected[i], glsmFloatBuffer.get(i), 0.0001f, "GLSM State Mismatch: " + i)
));
}
public static void verifyNotDefaultState(int glCap, float[] expected, String message) {
GL11.glGetFloat(glCap, (FloatBuffer) glFloatBuffer.clear());
GLStateManager.glGetFloat(glCap, (FloatBuffer) glsmFloatBuffer.clear());
IntStream.range (0, expected.length).forEach(i -> assertAll(message,
() -> assertNotEquals(expected[i], glFloatBuffer.get(i), 0.0001f, "GL State Mismatch: " + i),
() -> assertNotEquals(expected[i], glsmFloatBuffer.get(i), 0.0001f, "GLSM State Mismatch: " + i)
));
}
public static void verifyState(int glCap, boolean[] expected) {
verifyState(glCap, expected, "Boolean State Mismatch");
}
static final ByteBuffer glByteBuffer = BufferUtils.createByteBuffer(16);
static final ByteBuffer glsmByteBuffer = BufferUtils.createByteBuffer(16);
public static void verifyState(int glCap, boolean[] expected, String message) {
GL11.glGetBoolean(glCap, (ByteBuffer) glByteBuffer.clear());
GLStateManager.glGetBoolean(glCap, (ByteBuffer) glsmByteBuffer.clear());
IntStream.range (0, expected.length).forEach(i -> assertAll(message,
() -> assertEquals(expected[i] ? GL11.GL_TRUE : GL11.GL_FALSE, glByteBuffer.get(i), "GL State Mismatch: " + i),
() -> assertEquals(expected[i] ? GL11.GL_TRUE : GL11.GL_FALSE, glsmByteBuffer.get(i), "GLSM State Mismatch: " + i)
));
}
public static void verifyLightState(int glLight, int pname, float[] expected, String message) {
GL11.glGetLight(glLight, pname, (FloatBuffer) glFloatBuffer.clear());
GLStateManager.glGetLight(glLight, pname, (FloatBuffer) glsmFloatBuffer.clear());
IntStream.range (0, expected.length).forEach(i -> assertAll(message,
() -> assertEquals(expected[i], glFloatBuffer.get(i), 0.0001f, "GL State Mismatch: " + i),
() -> assertEquals(expected[i], glsmFloatBuffer.get(i), 0.0001f, "GLSM State Mismatch: " + i)
));
}
}