diff options
Diffstat (limited to 'Занимательное программирование/4/5_3d/src/main/java/net')
9 files changed, 801 insertions, 0 deletions
diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/KruskalMaze.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/KruskalMaze.java new file mode 100644 index 0000000..513a998 --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/KruskalMaze.java @@ -0,0 +1,124 @@ +package net.caraus.labyrinth; + +import java.util.ArrayList; +import java.util.Random; + +public final class KruskalMaze { + private Maze theMaze; + private int[][] mark; + + public KruskalMaze(int width, int height) { + this.theMaze = new Maze(width, height); + } + + private void breakWall(Wall wall) { + if (wall.delta().x() == -1) { + this.theMaze.at(wall.xy()).leftWall(false); + } else if (wall.delta().x() == 1) { + this.theMaze.at(wall.xy().x() + 1, wall.xy().y()).leftWall(false); + } else if (wall.delta().y() == -1) { + this.theMaze.at(wall.xy()).upWall(false); + } else { + this.theMaze.at(wall.xy().x(), wall.xy().y() + 1).upWall(false); + } + } + + public boolean isConnected(Point start, Point finish) { + this.mark = new int[this.theMaze.width()][this.theMaze.height()]; // Метки локаций. + + for (int x = 0; x < this.theMaze.width(); ++x) { + for (int y = 0; y < this.theMaze.height(); ++y) { + this.mark[x][y] = 0; + } + } + this.mark[start.x()][start.y()] = 1; + + return solve(start, finish); + } + + private boolean solve(Point start, Point finish) { + // Используем алгоритм волновой трассировки. + int n = 1; + + // Локации со следующим N. + ArrayList<Point> locations = new ArrayList<>(); + locations.add(start); + + do { + ArrayList<Point> nextLocations = new ArrayList<>(); + // Посетить локации, помеченные числом N. + for (var nLocation : locations) { + // Просмотр соседей. + for (int i = 0; i < 4; ++i) { + var neighbour = new Point(nLocation.x() + Maze.DX[i], nLocation.y() + Maze.DY[i]); + + if (this.theMaze.canGo(nLocation, i) && this.mark[neighbour.x()][neighbour.y()] == 0) { + // Локация доступна и помечена нулем. + // Есть шанс найти решения. + nextLocations.add(neighbour); + this.mark[neighbour.x()][neighbour.y()] = n + 1; + + if (neighbour.x() == finish.x() && neighbour.y() == finish.y()) { + return true; + } + } + } + } + locations = nextLocations; + ++n; + } while (!locations.isEmpty()); + + return false; + } + + public Maze generate() { + final var wallCount = (this.theMaze.width() - 1) * this.theMaze.height() + + (this.theMaze.height() - 1) * this.theMaze.width(); + ArrayList<Wall> walls = new ArrayList<>(wallCount); + ArrayList<Double> temp = new ArrayList<>(wallCount); + var random = new Random(); + + // Заполнение массива Temp случайными числами. + for (int i = 0; i < wallCount; ++i) { + temp.add(random.nextDouble()); + } + // Заполнение массива стен. + // Сначала все горизонтальные. + for (var i = 1; i < this.theMaze.width(); ++i) { + for (var j = 0; j < this.theMaze.height(); ++j) { + walls.add(new Wall(new Point(i, j), new Point(-1, 0))); + } + } + // Затем все вертикальные. + for (var i = 0; i < this.theMaze.width(); ++i) { + for (var j = 1; j < this.theMaze.height(); ++j) { + walls.add(new Wall(new Point(i, j), new Point(0, -1))); + } + } + for (var i = 0; i < wallCount; ++i) { + for (var j = i; j < wallCount; ++j) { + // Перемешиваем массив стен. + if (temp.get(i) > temp.get(j)) { + var tempr = temp.get(i); + temp.set(i, temp.get(j)); + temp.set(j, tempr); + + var tempw = walls.get(i); + walls.set(i, walls.get(j)); + walls.set(j, tempw); + } + } + } + var locations = this.theMaze.width() * this.theMaze.height(); + int i = 0; + while (locations > 1) { + var curWall = walls.get(i); + ++i; + if (!isConnected(curWall.xy(), curWall.end())) { + breakWall(curWall); + --locations; + } + } + return this.theMaze; + } +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Location.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Location.java new file mode 100644 index 0000000..97077be --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Location.java @@ -0,0 +1,32 @@ +package net.caraus.labyrinth; + +public class Location { + private boolean leftWall; + private boolean upWall; + + Location(boolean leftWall, boolean upWall) { + this.leftWall = leftWall; + this.upWall = upWall; + } + + public boolean leftWall() { + return this.leftWall; + } + + public void leftWall(boolean leftWall) { + this.leftWall = leftWall; + } + + public boolean upWall() { + return this.upWall; + } + + public void upWall(boolean upWall) { + this.upWall = upWall; + } + + @Override + public String toString() { + return String.format("(%s, %s)", leftWall, upWall); + } +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Main.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Main.java new file mode 100644 index 0000000..35a6c01 --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Main.java @@ -0,0 +1,167 @@ +package net.caraus.labyrinth; + +import com.badlogic.gdx.ApplicationListener; +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.GL32; +import com.badlogic.gdx.graphics.PerspectiveCamera; +import com.badlogic.gdx.graphics.VertexAttributes.Usage; +import com.badlogic.gdx.graphics.g3d.Material; +import com.badlogic.gdx.graphics.g3d.Model; +import com.badlogic.gdx.graphics.g3d.ModelBatch; +import com.badlogic.gdx.graphics.g3d.ModelInstance; +import com.badlogic.gdx.graphics.g3d.attributes.BlendingAttribute; +import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute; +import com.badlogic.gdx.graphics.g3d.utils.MeshPartBuilder; +import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder; +import com.badlogic.gdx.graphics.glutils.ShapeRenderer; +import static com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType; +import com.badlogic.gdx.math.Vector3; +import com.badlogic.gdx.utils.ScreenUtils; + +public class Main implements ApplicationListener { + + public ModelBatch modelBatch; + public Model model; + public ModelInstance instance; + public MazeInputProcessor camController; + public ShapeRenderer shapeRenderer; + public Maze maze; + + private static final float WALL_SIZE = 5; + + @Override + public void create() { + this.modelBatch = new ModelBatch(); + this.shapeRenderer = new ShapeRenderer(); + var cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight()); + + cam.position.set(0f, 0f, 0f); + cam.lookAt(0, WALL_SIZE, 0); + cam.near = 1f; + cam.far = 300f; + cam.update(); + + this.maze = new KruskalMaze(15, 9).generate(); + this.camController = new MazeInputProcessor(this.maze, cam, WALL_SIZE); + Gdx.input.setInputProcessor(camController); + + ModelBuilder worldBuilder = new ModelBuilder(); + worldBuilder.begin(); + + for (var x = 0; x < this.maze.width(); ++x) { + for (var y = 0; y < this.maze.height(); ++y) { + buildLocation(worldBuilder, x, y); + } + buildLocation(worldBuilder, new Location(false, true), + new Vector3(x * WALL_SIZE * 2, this.maze.height() * WALL_SIZE * 2, 0), + String.format("lx%dy%d", x, this.maze.height())); + } + for (var y = 0; y < this.maze.height(); ++y) { + buildLocation(worldBuilder, new Location(true, false), + new Vector3(this.maze.width() * WALL_SIZE * 2, y * WALL_SIZE * 2, 0), + String.format("lx%dy%d", this.maze.width(), y)); + } + buildFloor(worldBuilder); + this.model = worldBuilder.end(); + this.instance = new ModelInstance(this.model); + } + + private static Vector3 makeTranslation(int x, int y) { + return new Vector3(x * WALL_SIZE * 2, y * WALL_SIZE * 2, 0); + } + + // Пол. + private void buildFloor(ModelBuilder worldBuilder) { + MeshPartBuilder meshBuilder = worldBuilder.part("floor", + GL32.GL_TRIANGLES, Usage.Position | Usage.Normal, + new Material(ColorAttribute.createDiffuse(Color.ORANGE))); + + var farX = -WALL_SIZE + this.maze.width() * WALL_SIZE * 2; + var farY = -WALL_SIZE + this.maze.height() * WALL_SIZE * 2; + + meshBuilder.rect(new MeshPartBuilder.VertexInfo().setPos(-WALL_SIZE, -WALL_SIZE, -WALL_SIZE), + new MeshPartBuilder.VertexInfo().setPos(farX, -WALL_SIZE, -WALL_SIZE), + new MeshPartBuilder.VertexInfo().setPos(farX, farY, -WALL_SIZE), + new MeshPartBuilder.VertexInfo().setPos(-WALL_SIZE, farY, -WALL_SIZE)); + } + + private static void buildLocation(ModelBuilder worldBuilder, + Location builtLocation, Vector3 translation, String partName) { + var corner00 = new Vector3(); + var corner10 = new Vector3(); + var corner11 = new Vector3(); + var corner01 = new Vector3(); + + MeshPartBuilder meshBuilder = worldBuilder.part(partName, + GL32.GL_TRIANGLES, Usage.Position | Usage.Normal, new Material(new BlendingAttribute(0.9f))); + + if (builtLocation.leftWall()) { + meshBuilder.rect(corner00.set(-WALL_SIZE, -WALL_SIZE, -WALL_SIZE).add(translation), + corner10.set(-WALL_SIZE, WALL_SIZE, -WALL_SIZE).add(translation), + corner11.set(-WALL_SIZE, WALL_SIZE, WALL_SIZE).add(translation), + corner01.set(-WALL_SIZE, -WALL_SIZE, WALL_SIZE).add(translation), + null); + meshBuilder.rect(corner01.set(-WALL_SIZE, -WALL_SIZE, WALL_SIZE).add(translation), + corner11.set(-WALL_SIZE, WALL_SIZE, WALL_SIZE).add(translation), + corner10.set(-WALL_SIZE, WALL_SIZE, -WALL_SIZE).add(translation), + corner00.set(-WALL_SIZE, -WALL_SIZE, -WALL_SIZE).add(translation), + null); + } + if (builtLocation.upWall()) { + meshBuilder.rect(corner00.set(-WALL_SIZE, -WALL_SIZE, -WALL_SIZE).add(translation), + corner10.set(WALL_SIZE, -WALL_SIZE, -WALL_SIZE).add(translation), + corner11.set(WALL_SIZE, -WALL_SIZE, WALL_SIZE).add(translation), + corner01.set(-WALL_SIZE, -WALL_SIZE, WALL_SIZE).add(translation), + null); + meshBuilder.rect(corner01.set(-WALL_SIZE, -WALL_SIZE, WALL_SIZE).add(translation), + corner11.set(WALL_SIZE, -WALL_SIZE, WALL_SIZE).add(translation), + corner10.set(WALL_SIZE, -WALL_SIZE, -WALL_SIZE).add(translation), + corner00.set(-WALL_SIZE, -WALL_SIZE, -WALL_SIZE).add(translation), + null); + } + } + + private void buildLocation(ModelBuilder worldBuilder, int x, int y) { + var translation = new Vector3(x * WALL_SIZE * 2, y * WALL_SIZE * 2, 0); + + buildLocation(worldBuilder, this.maze.at(x, y), translation, String.format("lx%dy%d", x, y)); + } + + @Override + public void render() { + this.camController.update(); + + Gdx.gl.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); + ScreenUtils.clear(0.15f, 0.15f, 0.2f, 1f); + + Gdx.gl.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight()); + this.modelBatch.begin(this.camController.getCamera()); + this.modelBatch.render(this.instance); + this.modelBatch.end(); + + this.shapeRenderer.begin(ShapeType.Line); + this.shapeRenderer.setColor(Color.BLUE); + this.maze.draw(this.shapeRenderer); + this.shapeRenderer.end(); + } + + @Override + public void dispose() { + this.modelBatch.dispose(); + this.model.dispose(); + this.shapeRenderer.dispose(); + } + + @Override + public void resume() { + } + + @Override + public void resize(int width, int height) { + } + + @Override + public void pause() { + } +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Maze.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Maze.java new file mode 100644 index 0000000..828c1d8 --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Maze.java @@ -0,0 +1,99 @@ +package net.caraus.labyrinth; + +import com.badlogic.gdx.graphics.glutils.ShapeRenderer; +import com.badlogic.gdx.math.Vector2; + +import java.io.BufferedReader; +import java.io.Reader; +import java.io.IOException; + +public final class Maze { + private Location[][] maze; + + public static final int[] DX = {1, 0, -1, 0}; + public static final int[] DY = {0, -1, 0, 1}; + public static final float CELL_SIZE = 30.0f; + + public Maze(Reader inputReader) throws IOException { + BufferedReader reader = new BufferedReader(inputReader); + + String[] inputPair = reader.readLine().split(" "); + var width = Integer.parseInt(inputPair[0]); + var height = Integer.parseInt(inputPair[1]); + + this.maze = new Location[width + 1][height + 1]; + + for (var y = 0; y <= height; ++y) { + for (var x = 0; x <= width; ++x) { + if (y == height || x == width) { + this.maze[x][y] = new Location(true, true); + } else { + inputPair = reader.readLine().split(" "); + this.maze[x][y] = new Location(inputPair[1].equals("1"), inputPair[0].equals("1")); + } + } + } + } + + public Maze(int width, int height) { + this.maze = new Location[width + 1][height + 1]; + + // Все стены изначально существуют. + for (int x = 0; x <= width; ++x) { + for (int y = 0; y <= height; ++y) { + this.maze[x][y] = new Location(true, true); + } + } + } + + public int width() { + return this.maze == null ? 0 : this.maze.length - 1; + } + + public int height() { + return this.maze == null ? 0 : this.maze[0].length - 1; + } + + public void draw(ShapeRenderer shape) { + for (var x = 0; x < width(); ++x) { + for (var y = 0; y < height(); ++y) { + var start = new Vector2((x + 1) * CELL_SIZE, (height() - y + 1) * CELL_SIZE); + + if (this.maze[x][y].upWall()) { + var end = new Vector2(start).add(CELL_SIZE, 0); + + shape.line(start, end); + } + if (this.maze[x][y].leftWall()) { + var end = new Vector2(start).sub(0, CELL_SIZE); + + shape.line(start, end); + } + } + } + // Рисуем нижнюю и правую стены. + var edge = new Vector2(CELL_SIZE * (width() + 1), CELL_SIZE); + shape.line(new Vector2(CELL_SIZE, CELL_SIZE), edge); + shape.line(new Vector2(edge).add(0, height() * CELL_SIZE), edge); + } + + public boolean canGo(Point xy, int deltaIndex) { + if (DX[deltaIndex] == -1) { + return !this.maze[xy.x()][xy.y()].leftWall(); + } else if (DX[deltaIndex] == 1) { + return !this.maze[xy.x() + 1][xy.y()].leftWall(); + } else if (DY[deltaIndex] == -1) { + return !this.maze[xy.x()][xy.y()].upWall(); + } else { + return !this.maze[xy.x()][xy.y() + 1].upWall(); + } + } + + public Location at(int x, int y) { + return this.maze[x][y]; + } + + public Location at(Point xy) { + return at(xy.x(), xy.y()); + } +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/MazeInputProcessor.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/MazeInputProcessor.java new file mode 100644 index 0000000..7303829 --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/MazeInputProcessor.java @@ -0,0 +1,111 @@ +package net.caraus.labyrinth; + +import com.badlogic.gdx.InputProcessor; +import static com.badlogic.gdx.Input.Keys; +import com.badlogic.gdx.graphics.PerspectiveCamera; +import com.badlogic.gdx.math.Vector3; + +public final class MazeInputProcessor implements InputProcessor { + + public PerspectiveCamera cam; + private short direction = 3; + private Point position = new Point(0, 0); + private final float step; + private Maze maze; + + public MazeInputProcessor(Maze maze, PerspectiveCamera cam, float wallSize) { + this.cam = cam; + this.step = wallSize * 2; + this.maze = maze; + } + + public void update() { + this.cam.update(); + } + + public PerspectiveCamera getCamera() { + return this.cam; + } + + @Override + public boolean keyDown(int keycode) { + if (keycode == Keys.RIGHT) { + turnRight(); + return true; + } else if (keycode == Keys.LEFT) { + turnLeft(); + return true; + } else if (keycode == Keys.UP) { + stepForward(); + } + return false; + } + + private void stepForward() { + if (!this.maze.canGo(this.position, this.direction)) { + return; + } + this.position = new Point(this.position.x() + Maze.DX[this.direction], + this.position.y() + Maze.DY[this.direction]); + this.cam.position.set(this.position.x() * this.step, + this.position.y() * this.step, 0.0f); + } + + private void turnRight() { + if (this.direction >= 3) { + this.direction = 0; + } else { + ++this.direction; + } + this.cam.rotate(90, 0, 0, -1); + } + + private void turnLeft() { + if (this.direction <= 0) { + this.direction = 3; + } else { + --this.direction; + } + this.cam.rotate(90, 0, 0, 1); + } + + @Override + public boolean keyUp(int keycode) { + return false; + } + + @Override + public boolean keyTyped(char character) { + return false; + } + + @Override + public boolean touchDown(int x, int y, int pointer, int button) { + return false; + } + + @Override + public boolean touchUp(int x, int y, int pointer, int button) { + return false; + } + + @Override + public boolean touchDragged(int x, int y, int pointer) { + return false; + } + + @Override + public boolean touchCancelled(int x, int y, int pointer, int button) { + return false; + } + + @Override + public boolean mouseMoved(int x, int y) { + return false; + } + + @Override + public boolean scrolled(float amountX, float amountY) { + return false; + } +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Point.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Point.java new file mode 100644 index 0000000..6f70d4c --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Point.java @@ -0,0 +1,4 @@ +package net.caraus.labyrinth; + +public record Point(int x, int y) { +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Wall.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Wall.java new file mode 100644 index 0000000..e8615bd --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/Wall.java @@ -0,0 +1,15 @@ +package net.caraus.labyrinth; + +public record Wall(Point xy, Point delta) { + public int x() { + return this.xy.x() + this.delta.x(); + } + + public int y() { + return this.xy.y() + this.delta.y(); + } + + public Point end() { + return new Point(x(), y()); + } +} diff --git a/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/lwjgl3/Lwjgl3Launcher.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/lwjgl3/Lwjgl3Launcher.java new file mode 100644 index 0000000..cbdfa6c --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/lwjgl3/Lwjgl3Launcher.java @@ -0,0 +1,45 @@ +package net.caraus.labyrinth.lwjgl3; + +import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application; +import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration; +import net.caraus.labyrinth.Main; + +/** Launches the desktop (LWJGL3) application. */ +public class Lwjgl3Launcher { + public static void main(String[] args) { + if (StartupHelper.startNewJvmIfRequired()) return; // This handles macOS support and helps on Windows. + createApplication(); + } + + private static Lwjgl3Application createApplication() { + return new Lwjgl3Application(new Main(), getDefaultConfiguration()); + } + + private static Lwjgl3ApplicationConfiguration getDefaultConfiguration() { + Lwjgl3ApplicationConfiguration configuration = new Lwjgl3ApplicationConfiguration(); + configuration.setTitle("Labyrinth"); + //// 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.setWindowedMode(1366, 768); + //// 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/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/lwjgl3/StartupHelper.java b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/lwjgl3/StartupHelper.java new file mode 100644 index 0000000..b62cf6f --- /dev/null +++ b/Занимательное программирование/4/5_3d/src/main/java/net/caraus/labyrinth/lwjgl3/StartupHelper.java @@ -0,0 +1,204 @@ +/* + * 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 net.caraus.labyrinth.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); + } +} |