Move code over

11 files changed, 528 insertions, 0 deletions

diff --git a/lwjgl3/build.gradle b/lwjgl3/build.gradle
new file mode 100644
index 0000000..295b01b
--- /dev/null
+++ b/lwjgl3/build.gradle
@@ -0,0 +1,193 @@
+
+buildscript {
+  repositories {
+    gradlePluginPortal()
+  }
+  dependencies {
+    classpath "io.github.fourlastor:construo:2.1.0"
+    if(enableGraalNative == 'true') {
+      classpath "org.graalvm.buildtools.native:org.graalvm.buildtools.native.gradle.plugin:0.9.28"
+    }
+  }
+}
+plugins {
+  id "application"
+}
+apply plugin: 'io.github.fourlastor.construo'
+
+
+import io.github.fourlastor.construo.Target
+
+sourceSets.main.resources.srcDirs += [ rootProject.file('assets').path ]
+application.mainClass = 'coffee.liz.abstractionengine.lwjgl3.Lwjgl3Launcher'
+eclipse.project.name = appName + '-lwjgl3'
+java.sourceCompatibility = 24
+java.targetCompatibility = 24
+if (JavaVersion.current().isJava9Compatible()) {
+        compileJava.options.release.set(24)
+}
+
+dependencies {
+  implementation "com.badlogicgames.gdx:gdx-backend-lwjgl3:$gdxVersion"
+  implementation "com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-desktop"
+  implementation "com.badlogicgames.gdx:gdx-lwjgl3-angle:$gdxVersion"
+  implementation "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-desktop"
+  implementation project(':core')
+
+  if(enableGraalNative == 'true') {
+    implementation "io.github.berstanio:gdx-svmhelper-backend-lwjgl3:$graalHelperVersion"
+      implementation "io.github.berstanio:gdx-svmhelper-extension-freetype:$graalHelperVersion"
+
+    }
+}
+
+def os = System.properties['os.name'].toLowerCase(Locale.ROOT)
+
+run {
+  workingDir = rootProject.file('assets').path
+// You can uncomment the next line if your IDE claims a build failure even when the app closed properly.
+  //setIgnoreExitValue(true)
+
+  if (os.contains('mac')) jvmArgs += "-XstartOnFirstThread"
+}
+
+// Run with JVM debugger listening on port 5005
+tasks.register('runDebug', JavaExec) {
+  group = 'application'
+  description = 'Run the application with the JVM debugger listening on 5005'
+  classpath = sourceSets.main.runtimeClasspath
+  mainClass = application.mainClass
+  workingDir = rootProject.file('assets').path
+  if (os.contains('mac')) jvmArgs += "-XstartOnFirstThread"
+  jvmArgs += "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005"
+}
+
+jar {
+// sets the name of the .jar file this produces to the name of the game or app, with the version after.
+  archiveFileName.set("${appName}-${projectVersion}.jar")
+// the duplicatesStrategy matters starting in Gradle 7.0; this setting works.
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+  dependsOn configurations.runtimeClasspath
+  from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
+// these "exclude" lines remove some unnecessary duplicate files in the output JAR.
+  exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    exclude('META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+// setting the manifest makes the JAR runnable.
+// enabling native access helps avoid a warning when Java 24 or later runs the JAR.
+  manifest {
+    attributes 'Main-Class': application.mainClass, 'Enable-Native-Access': 'ALL-UNNAMED'
+  }
+// this last step may help on some OSes that need extra instruction to make runnable JARs.
+  doLast {
+    file(archiveFile).setExecutable(true, false)
+  }
+}
+
+// Builds a JAR that only includes the files needed to run on macOS, not Windows or Linux.
+// The file size for a Mac-only JAR is about 7MB smaller than a cross-platform JAR.
+tasks.register("jarMac") {
+  dependsOn("jar")
+  group("build")
+  jar.archiveFileName.set("${appName}-${projectVersion}-mac.jar")
+  jar.exclude("windows/x86/**", "windows/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**", "**/*.dll", "**/*.so",
+    'META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    jar.exclude("windows/x86/**", "windows/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**",
+      'META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+}
+
+// Builds a JAR that only includes the files needed to run on Linux, not Windows or macOS.
+// The file size for a Linux-only JAR is about 5MB smaller than a cross-platform JAR.
+tasks.register("jarLinux") {
+  dependsOn("jar")
+  group("build")
+  jar.archiveFileName.set("${appName}-${projectVersion}-linux.jar")
+  jar.exclude("windows/x86/**", "windows/x64/**", "macos/arm64/**", "macos/x64/**", "**/*.dll", "**/*.dylib",
+    'META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    jar.exclude("windows/x86/**", "windows/x64/**", "macos/arm64/**", "macos/x64/**",
+      'META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+}
+
+// Builds a JAR that only includes the files needed to run on Windows, not Linux or macOS.
+// The file size for a Windows-only JAR is about 6MB smaller than a cross-platform JAR.
+tasks.register("jarWin") {
+  dependsOn("jar")
+  group("build")
+  jar.archiveFileName.set("${appName}-${projectVersion}-win.jar")
+  jar.exclude("macos/arm64/**", "macos/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**", "**/*.dylib", "**/*.so",
+    'META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    jar.exclude("macos/arm64/**", "macos/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**",
+      'META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+}
+
+construo {
+    // name of the executable
+    name.set(appName)
+    // human-readable name, used for example in the `.app` name for macOS
+    humanName.set(appName)
+
+    targets.configure {
+      register("linuxX64", Target.Linux) {
+        architecture.set(Target.Architecture.X86_64)
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_x64_linux_hotspot_17.0.15_6.tar.gz")
+        // Linux does not currently have a way to set the icon on the executable
+      }
+      register("macM1", Target.MacOs) {
+        architecture.set(Target.Architecture.AARCH64)
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_aarch64_mac_hotspot_17.0.15_6.tar.gz")
+        // macOS needs an identifier
+        identifier.set("coffee.liz.abstractionengine." + appName)
+        // Optional: icon for macOS, as an ICNS file
+        macIcon.set(project.file("icons/logo.icns"))
+      }
+      register("macX64", Target.MacOs) {
+        architecture.set(Target.Architecture.X86_64)
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_x64_mac_hotspot_17.0.15_6.tar.gz")
+        // macOS needs an identifier
+        identifier.set("coffee.liz.abstractionengine." + appName)
+        // Optional: icon for macOS, as an ICNS file
+        macIcon.set(project.file("icons/logo.icns"))
+      }
+      register("winX64", Target.Windows) {
+        architecture.set(Target.Architecture.X86_64)
+        // Optional: icon for Windows, as a PNG
+        icon.set(project.file("icons/logo.png"))
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_x64_windows_hotspot_17.0.15_6.zip")
+        // Uncomment the next line to show a console when the game runs, to print messages.
+        //useConsole.set(true)
+      }
+    }
+}
+
+// Equivalent to the jar task; here for compatibility with gdx-setup.
+tasks.register('dist') {
+  dependsOn 'jar'
+}
+
+distributions {
+  main {
+    contents {
+      into('libs') {
+        project.configurations.runtimeClasspath.files.findAll { file ->
+          file.getName() != project.tasks.jar.outputs.files.singleFile.name
+        }.each { file ->
+          exclude file.name
+        }
+      }
+    }
+  }
+}
+
+startScripts.dependsOn(':lwjgl3:jar')
+startScripts.classpath = project.tasks.jar.outputs.files
+
+if(enableGraalNative == 'true') {
+  apply from: file("nativeimage.gradle")
+}
diff --git a/lwjgl3/icons/logo.icns b/lwjgl3/icons/logo.icns
new file mode 100644
index 0000000..5e41ad7
--- /dev/null
+++ b/lwjgl3/icons/logo.icns
diff --git a/lwjgl3/icons/logo.ico b/lwjgl3/icons/logo.ico
new file mode 100644
index 0000000..c4f2d5e
--- /dev/null
+++ b/lwjgl3/icons/logo.ico
diff --git a/lwjgl3/icons/logo.png b/lwjgl3/icons/logo.png
new file mode 100644
index 0000000..f810616
--- /dev/null
+++ b/lwjgl3/icons/logo.png
diff --git a/lwjgl3/nativeimage.gradle b/lwjgl3/nativeimage.gradle
new file mode 100644
index 0000000..bee3fd2
--- /dev/null
+++ b/lwjgl3/nativeimage.gradle
@@ -0,0 +1,54 @@
+
+project(":lwjgl3") {
+  apply plugin: "org.graalvm.buildtools.native"
+
+  graalvmNative {
+    binaries {
+      main {
+        imageName = appName
+        mainClass = application.mainClass
+        requiredVersion = '23.0'
+        buildArgs.add("-march=compatibility")
+        jvmArgs.addAll("-Dfile.encoding=UTF8")
+        sharedLibrary = false
+        resources.autodetect()
+      }
+    }
+  }
+
+  run {
+    doNotTrackState("Running the app should not be affected by Graal.")
+  }
+
+  // Modified from https://lyze.dev/2021/04/29/libGDX-Internal-Assets-List/ ; thanks again, Lyze!
+  // This creates a resource-config.json file based on the contents of the assets folder (and the libGDX icons).
+  // This file is used by Graal Native to embed those specific files.
+  // This has to run before nativeCompile, so it runs at the start of an unrelated resource-handling command.
+  generateResourcesConfigFile.doFirst {
+    def assetsFolder = new File("${project.rootDir}/assets/")
+    def lwjgl3 = project(':lwjgl3')
+    def resFolder = new File("${lwjgl3.projectDir}/src/main/resources/META-INF/native-image/${lwjgl3.ext.appName}")
+    resFolder.mkdirs()
+    def resFile = new File(resFolder, "resource-config.json")
+    resFile.delete()
+    resFile.append(
+            """{
+  "resources":{
+  "includes":[
+    {
+      "pattern": ".*(""")
+    // This adds every filename in the assets/ folder to a pattern that adds those files as resources.
+    fileTree(assetsFolder).each {
+      // The backslash-Q and backslash-E escape the start and end of a literal string, respectively.
+      resFile.append("\\\\Q${it.name}\\\\E|")
+    }
+    // We also match all of the window icon images this way and the font files that are part of libGDX.
+    resFile.append(
+            """libgdx.+\\\\.png|lsans.+)"
+    }
+  ]},
+  "bundles":[]
+}"""
+    )
+  }
+}
diff --git a/lwjgl3/src/main/java/coffee/liz/abstractionengine/lwjgl3/Lwjgl3Launcher.java b/lwjgl3/src/main/java/coffee/liz/abstractionengine/lwjgl3/Lwjgl3Launcher.java
new file mode 100644
index 0000000..1c67c62
--- /dev/null
+++ b/lwjgl3/src/main/java/coffee/liz/abstractionengine/lwjgl3/Lwjgl3Launcher.java
@@ -0,0 +1,63 @@
+package coffee.liz.abstractionengine.lwjgl3;
+
+import coffee.liz.abstractionengine.app.AbstractionEngineGame;
+
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application;
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration;
+import com.badlogic.gdx.graphics.glutils.HdpiMode;
+
+/** Launches the desktop (LWJGL3) application. */
+public class Lwjgl3Launcher {
+	public static void main(final String[] args) {
+		if (StartupHelper.startNewJvmIfRequired())
+			return; // This handles macOS support and helps on Windows.
+		createApplication();
+	}
+
+	private static Lwjgl3Application createApplication() {
+		return new Lwjgl3Application(new AbstractionEngineGame(), getDefaultConfiguration());
+	}
+
+	private static Lwjgl3ApplicationConfiguration getDefaultConfiguration() {
+		final Lwjgl3ApplicationConfiguration configuration = new Lwjgl3ApplicationConfiguration();
+		configuration.setTitle("The Abstraction Engine");
+		//// Vsync limits the frames per second to what your hardware can display, and
+		//// helps eliminate
+		//// screen tearing. This setting doesn't always work on Linux, so the line
+		//// after is a safeguard.
+		configuration.useVsync(true);
+		//// Limits FPS to the refresh rate of the currently active monitor, plus 1 to
+		//// try to match fractional
+		//// refresh rates. The Vsync setting above should limit the actual FPS to match
+		//// the monitor.
+		configuration.setForegroundFPS(Lwjgl3ApplicationConfiguration.getDisplayMode().refreshRate + 1);
+		//// If you remove the above line and set Vsync to false, you can get unlimited
+		//// FPS, which can be
+		//// useful for testing performance, but can also be very stressful to some
+		//// hardware.
+		//// You may also need to configure GPU drivers to fully disable Vsync; this can
+		//// cause screen tearing.
+
+		configuration.setHdpiMode(HdpiMode.Logical);
+
+		configuration.setWindowedMode(1024, 1024);
+		configuration.setDecorated(true);
+		//// You can change these files; they are in lwjgl3/src/main/resources/ .
+		//// They can also be loaded from the root of assets/ .
+		configuration.setWindowIcon("libgdx128.png", "libgdx64.png", "libgdx32.png", "libgdx16.png");
+
+		//// This should improve compatibility with Windows machines with buggy OpenGL
+		//// drivers, Macs
+		//// with Apple Silicon that have to emulate compatibility with OpenGL anyway,
+		//// and more.
+		//// This uses the dependency `com.badlogicgames.gdx:gdx-lwjgl3-angle` to
+		//// function.
+		//// You can choose to remove the following line and the mentioned dependency if
+		//// you want; they
+		//// are not intended for games that use GL30 (which is compatibility with
+		//// OpenGL ES 3.0).
+		configuration.setOpenGLEmulation(Lwjgl3ApplicationConfiguration.GLEmulation.ANGLE_GLES20, 0, 0);
+
+		return configuration;
+	}
+}
diff --git a/lwjgl3/src/main/java/coffee/liz/abstractionengine/lwjgl3/StartupHelper.java b/lwjgl3/src/main/java/coffee/liz/abstractionengine/lwjgl3/StartupHelper.java
new file mode 100644
index 0000000..21520f9
--- /dev/null
+++ b/lwjgl3/src/main/java/coffee/liz/abstractionengine/lwjgl3/StartupHelper.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2020 damios
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//Note, the above license and copyright applies to this file only.
+
+package coffee.liz.abstractionengine.lwjgl3;
+
+import com.badlogic.gdx.Version;
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3NativesLoader;
+import org.lwjgl.system.macosx.LibC;
+import org.lwjgl.system.macosx.ObjCRuntime;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.lang.management.ManagementFactory;
+import java.util.ArrayList;
+
+import static org.lwjgl.system.JNI.invokePPP;
+import static org.lwjgl.system.JNI.invokePPZ;
+import static org.lwjgl.system.macosx.ObjCRuntime.objc_getClass;
+import static org.lwjgl.system.macosx.ObjCRuntime.sel_getUid;
+
+/**
+ * Adds some utilities to ensure that the JVM was started with the
+ * {@code -XstartOnFirstThread} argument, which is required on macOS for LWJGL 3
+ * to function. Also helps on Windows when users have names with characters from
+ * outside the Latin alphabet, a common cause of startup crashes. <br>
+ * <a href=
+ * "https://jvm-gaming.org/t/starting-jvm-on-mac-with-xstartonfirstthread-programmatically/57547">Based
+ * on this java-gaming.org post by kappa</a>
+ * 
+ * @author damios
+ */
+public class StartupHelper {
+
+	private static final String JVM_RESTARTED_ARG = "jvmIsRestarted";
+
+	private StartupHelper() {
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Starts a new JVM if the application was started on macOS without the
+	 * {@code -XstartOnFirstThread} argument. This also includes some code for
+	 * Windows, for the case where the user's home directory includes certain
+	 * non-Latin-alphabet characters (without this code, most LWJGL3 apps fail
+	 * immediately for those users). Returns whether a new JVM was started and thus
+	 * no code should be executed.
+	 * <p>
+	 * <u>Usage:</u>
+	 *
+	 * <pre>
+	 * <code>
+	 * public static void main(String... args) {
+	 * 	if (StartupHelper.startNewJvmIfRequired(true)) return; // This handles macOS support and helps on Windows.
+	 * 	// after this is the actual main method code
+	 * }
+	 * </code>
+	 * </pre>
+	 *
+	 * @param redirectOutput
+	 *            whether the output of the new JVM should be rerouted to the old
+	 *            JVM, so it can be accessed in the same place; keeps the old JVM
+	 *            running if enabled
+	 * @return whether a new JVM was started and thus no code should be executed in
+	 *         this one
+	 */
+	public static boolean startNewJvmIfRequired(boolean redirectOutput) {
+		String osName = System.getProperty("os.name").toLowerCase(java.util.Locale.ROOT);
+		if (!osName.contains("mac")) {
+			if (osName.contains("windows")) {
+				// Here, we are trying to work around an issue with how LWJGL3 loads its
+				// extracted .dll files.
+				// By default, LWJGL3 extracts to the directory specified by "java.io.tmpdir",
+				// which is usually the user's home.
+				// If the user's name has non-ASCII (or some non-alphanumeric) characters in it,
+				// that would fail.
+				// By extracting to the relevant "ProgramData" folder, which is usually
+				// "C:\ProgramData", we avoid this.
+				// We also temporarily change the "user.name" property to one without any chars
+				// that would be invalid.
+				// We revert our changes immediately after loading LWJGL3 natives.
+				String programData = System.getenv("ProgramData");
+				if (programData == null)
+					programData = "C:\\Temp\\"; // if ProgramData isn't set, try some fallback.
+				String prevTmpDir = System.getProperty("java.io.tmpdir", programData);
+				String prevUser = System.getProperty("user.name", "libGDX_User");
+				System.setProperty("java.io.tmpdir", programData + "/libGDX-temp");
+				System.setProperty("user.name",
+						("User_" + prevUser.hashCode() + "_GDX" + Version.VERSION).replace('.', '_'));
+				Lwjgl3NativesLoader.load();
+				System.setProperty("java.io.tmpdir", prevTmpDir);
+				System.setProperty("user.name", prevUser);
+			}
+			return false;
+		}
+
+		// There is no need for -XstartOnFirstThread on Graal native image
+		if (!System.getProperty("org.graalvm.nativeimage.imagecode", "").isEmpty()) {
+			return false;
+		}
+
+		// Checks if we are already on the main thread, such as from running via
+		// Construo.
+		long objc_msgSend = ObjCRuntime.getLibrary().getFunctionAddress("objc_msgSend");
+		long NSThread = objc_getClass("NSThread");
+		long currentThread = invokePPP(NSThread, sel_getUid("currentThread"), objc_msgSend);
+		boolean isMainThread = invokePPZ(currentThread, sel_getUid("isMainThread"), objc_msgSend);
+		if (isMainThread)
+			return false;
+
+		long pid = LibC.getpid();
+
+		// check whether -XstartOnFirstThread is enabled
+		if ("1".equals(System.getenv("JAVA_STARTED_ON_FIRST_THREAD_" + pid))) {
+			return false;
+		}
+
+		// check whether the JVM was previously restarted
+		// avoids looping, but most certainly leads to a crash
+		if ("true".equals(System.getProperty(JVM_RESTARTED_ARG))) {
+			System.err.println(
+					"There was a problem evaluating whether the JVM was started with the -XstartOnFirstThread argument.");
+			return false;
+		}
+
+		// Restart the JVM with -XstartOnFirstThread
+		ArrayList<String> jvmArgs = new ArrayList<>();
+		String separator = System.getProperty("file.separator", "/");
+		// The following line is used assuming you target Java 8, the minimum for
+		// LWJGL3.
+		String javaExecPath = System.getProperty("java.home") + separator + "bin" + separator + "java";
+		// If targeting Java 9 or higher, you could use the following instead of the
+		// above line:
+		// String javaExecPath = ProcessHandle.current().info().command().orElseThrow();
+
+		if (!(new File(javaExecPath)).exists()) {
+			System.err.println(
+					"A Java installation could not be found. If you are distributing this app with a bundled JRE, be sure to set the -XstartOnFirstThread argument manually!");
+			return false;
+		}
+
+		jvmArgs.add(javaExecPath);
+		jvmArgs.add("-XstartOnFirstThread");
+		jvmArgs.add("-D" + JVM_RESTARTED_ARG + "=true");
+		jvmArgs.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+		jvmArgs.add("-cp");
+		jvmArgs.add(System.getProperty("java.class.path"));
+		String mainClass = System.getenv("JAVA_MAIN_CLASS_" + pid);
+		if (mainClass == null) {
+			StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+			if (trace.length > 0) {
+				mainClass = trace[trace.length - 1].getClassName();
+			} else {
+				System.err.println("The main class could not be determined.");
+				return false;
+			}
+		}
+		jvmArgs.add(mainClass);
+
+		try {
+			if (!redirectOutput) {
+				ProcessBuilder processBuilder = new ProcessBuilder(jvmArgs);
+				processBuilder.start();
+			} else {
+				Process process = (new ProcessBuilder(jvmArgs)).redirectErrorStream(true).start();
+				BufferedReader processOutput = new BufferedReader(new InputStreamReader(process.getInputStream()));
+				String line;
+
+				while ((line = processOutput.readLine()) != null) {
+					System.out.println(line);
+				}
+
+				process.waitFor();
+			}
+		} catch (Exception e) {
+			System.err.println("There was a problem restarting the JVM");
+			e.printStackTrace();
+		}
+
+		return true;
+	}
+
+	/**
+	 * Starts a new JVM if the application was started on macOS without the
+	 * {@code -XstartOnFirstThread} argument. Returns whether a new JVM was started
+	 * and thus no code should be executed. Redirects the output of the new JVM to
+	 * the old one.
+	 * <p>
+	 * <u>Usage:</u>
+	 *
+	 * <pre>
+	 * public static void main(String... args) {
+	 * 	if (StartupHelper.startNewJvmIfRequired())
+	 * 		return; // This handles macOS support and helps on Windows.
+	 * 	// the actual main method code
+	 * }
+	 * </pre>
+	 *
+	 * @return whether a new JVM was started and thus no code should be executed in
+	 *         this one
+	 */
+	public static boolean startNewJvmIfRequired() {
+		return startNewJvmIfRequired(true);
+	}
+}
\ No newline at end of file
diff --git a/lwjgl3/src/main/resources/libgdx128.png b/lwjgl3/src/main/resources/libgdx128.png
new file mode 100644
index 0000000..f810616
--- /dev/null
+++ b/lwjgl3/src/main/resources/libgdx128.png
diff --git a/lwjgl3/src/main/resources/libgdx16.png b/lwjgl3/src/main/resources/libgdx16.png
new file mode 100644
index 0000000..a6b1327
--- /dev/null
+++ b/lwjgl3/src/main/resources/libgdx16.png
diff --git a/lwjgl3/src/main/resources/libgdx32.png b/lwjgl3/src/main/resources/libgdx32.png
new file mode 100644
index 0000000..9447b39
--- /dev/null
+++ b/lwjgl3/src/main/resources/libgdx32.png
diff --git a/lwjgl3/src/main/resources/libgdx64.png b/lwjgl3/src/main/resources/libgdx64.png
new file mode 100644
index 0000000..7513f3b
--- /dev/null
+++ b/lwjgl3/src/main/resources/libgdx64.png