Introduction

A voxel engine is a 3D graphics engine that uses volumetric pixels (voxels) as the fundamental building blocks for creating and rendering 3D worlds. This prototype demonstrates core voxel engine concepts including chunk-based world management, mesh generation, and basic rendering.

Core Architecture

Voxel Data Structure

public class Voxel { public static final byte TYPE_AIR = 0; public static final byte TYPE_GRASS = 1; public static final byte TYPE_DIRT = 2; public static final byte TYPE_STONE = 3; public static final byte TYPE_WATER = 4; public static final byte TYPE_WOOD = 5; public static final byte TYPE_LEAVES = 6; private byte type; private boolean transparent; private boolean solid; public Voxel(byte type) { this.type = type; updateProperties(); } private void updateProperties() { switch (type) { case TYPE_AIR: transparent = true; solid = false; break; case TYPE_WATER: transparent = true; solid = false; break; case TYPE_LEAVES: transparent = true; solid = true; break; default: transparent = false; solid = true; break; } } // Getters public byte getType() { return type; } public boolean isTransparent() { return transparent; } public boolean isSolid() { return solid; } public void setType(byte type) { this.type = type; updateProperties(); } // Static factory methods public static Voxel air() { return new Voxel(TYPE_AIR); } public static Voxel grass() { return new Voxel(TYPE_GRASS); } public static Voxel dirt() { return new Voxel(TYPE_DIRT); } public static Voxel stone() { return new Voxel(TYPE_STONE); } public static Voxel water() { return new Voxel(TYPE_WATER); } public static Voxel wood() { return new Voxel(TYPE_WOOD); } public static Voxel leaves() { return new Voxel(TYPE_LEAVES); } }

Chunk System

public class Chunk { public static final int CHUNK_SIZE = 16; public static final int CHUNK_HEIGHT = 256; private final Voxel[][][] voxels; private final int chunkX, chunkZ; private boolean needsRebuild; private ChunkMesh mesh; public Chunk(int chunkX, int chunkZ) { this.chunkX = chunkX; this.chunkZ = chunkZ; this.voxels = new Voxel[CHUNK_SIZE][CHUNK_HEIGHT][CHUNK_SIZE]; this.needsRebuild = true; initializeVoxels(); } private void initializeVoxels() { // Fill with air initially for (int x = 0; x < CHUNK_SIZE; x++) { for (int y = 0; y < CHUNK_HEIGHT; y++) { for (int z = 0; z < CHUNK_SIZE; z++) { voxels[x][y][z] = Voxel.air(); } } } } public Voxel getVoxel(int x, int y, int z) { if (isWithinBounds(x, y, z)) { return voxels[x][y][z]; } return Voxel.air(); } public void setVoxel(int x, int y, int z, Voxel voxel) { if (isWithinBounds(x, y, z)) { voxels[x][y][z] = voxel; needsRebuild = true; // Notify neighboring chunks if on border if (x == 0) notifyNeighbor(-1, 0); if (x == CHUNK_SIZE - 1) notifyNeighbor(1, 0); if (z == 0) notifyNeighbor(0, -1); if (z == CHUNK_SIZE - 1) notifyNeighbor(0, 1); } } private void notifyNeighbor(int dx, int dz) { // This would notify the world to mark neighboring chunk for rebuild // Implementation depends on world management } private boolean isWithinBounds(int x, int y, int z) { return x >= 0 && x < CHUNK_SIZE && y >= 0 && y < CHUNK_HEIGHT && z >= 0 && z < CHUNK_SIZE; } public boolean isSolid(int x, int y, int z) { Voxel voxel = getVoxel(x, y, z); return voxel != null && voxel.isSolid(); } public boolean isTransparent(int x, int y, int z) { Voxel voxel = getVoxel(x, y, z); return voxel != null && voxel.isTransparent(); } public void generateMesh() { this.mesh = new ChunkMesh(this); this.needsRebuild = false; } public ChunkMesh getMesh() { if (needsRebuild) { generateMesh(); } return mesh; } // World position conversion public int getWorldX(int localX) { return chunkX * CHUNK_SIZE + localX; } public int getWorldZ(int localZ) { return chunkZ * CHUNK_SIZE + localZ; } // Getters public int getChunkX() { return chunkX; } public int getChunkZ() { return chunkZ; } public boolean needsRebuild() { return needsRebuild; } }

Mesh Generation

Chunk Mesh Generation

public class ChunkMesh { private static final int VERTEX_SIZE = 8; // x, y, z, u, v, r, g, b private static final int INDICES_PER_FACE = 6; private FloatBuffer vertexBuffer; private IntBuffer indexBuffer; private int vertexCount; private int indexCount; public ChunkMesh(Chunk chunk) { generateMesh(chunk); } private void generateMesh(Chunk chunk) { List<Float> vertices = new ArrayList<>(); List<Integer> indices = new ArrayList<>(); for (int x = 0; x < Chunk.CHUNK_SIZE; x++) { for (int y = 0; y < Chunk.CHUNK_HEIGHT; y++) { for (int z = 0; z < Chunk.CHUNK_SIZE; z++) { Voxel voxel = chunk.getVoxel(x, y, z); if (voxel.isSolid()) { generateVoxelMesh(chunk, x, y, z, voxel, vertices, indices); } } } } createBuffers(vertices, indices); } private void generateVoxelMesh(Chunk chunk, int x, int y, int z, Voxel voxel, List<Float> vertices, List<Integer> indices) { // Check each face for visibility if (shouldRenderFace(chunk, x, y - 1, z)) { // Bottom face addFace(x, y, z, Face.BOTTOM, voxel, vertices, indices); } if (shouldRenderFace(chunk, x, y + 1, z)) { // Top face addFace(x, y, z, Face.TOP, voxel, vertices, indices); } if (shouldRenderFace(chunk, x - 1, y, z)) { // West face addFace(x, y, z, Face.WEST, voxel, vertices, indices); } if (shouldRenderFace(chunk, x + 1, y, z)) { // East face addFace(x, y, z, Face.EAST, voxel, vertices, indices); } if (shouldRenderFace(chunk, x, y, z - 1)) { // North face addFace(x, y, z, Face.NORTH, voxel, vertices, indices); } if (shouldRenderFace(chunk, x, y, z + 1)) { // South face addFace(x, y, z, Face.SOUTH, voxel, vertices, indices); } } private boolean shouldRenderFace(Chunk chunk, int x, int y, int z) { // Check if the neighboring voxel exists and is transparent if (x < 0 || x >= Chunk.CHUNK_SIZE || z < 0 || z >= Chunk.CHUNK_SIZE || y < 0 || y >= Chunk.CHUNK_HEIGHT) { return true; // Face at chunk border is always visible } Voxel neighbor = chunk.getVoxel(x, y, z); return !neighbor.isSolid() || neighbor.isTransparent(); } private void addFace(int x, int y, int z, Face face, Voxel voxel, List<Float> vertices, List<Integer> indices) { int baseVertex = vertexCount; float[] faceVertices = face.getVertices(x, y, z); float[] texCoords = getTextureCoordinates(voxel, face); float[] color = getColor(voxel); // Add vertices with texture coordinates and color for (int i = 0; i < 4; i++) { // Position vertices.add(faceVertices[i * 3]); vertices.add(faceVertices[i * 3 + 1]); vertices.add(faceVertices[i * 3 + 2]); // Texture coordinates vertices.add(texCoords[i * 2]); vertices.add(texCoords[i * 2 + 1]); // Color vertices.add(color[0]); vertices.add(color[1]); vertices.add(color[2]); } // Add indices (two triangles) int[] faceIndices = face.getIndices(); for (int index : faceIndices) { indices.add(baseVertex + index); } vertexCount += 4; indexCount += 6; } private float[] getTextureCoordinates(Voxel voxel, Face face) { // Simple texture coordinates - in real implementation, // this would look up from a texture atlas switch (voxel.getType()) { case Voxel.TYPE_GRASS: if (face == Face.TOP) return new float[]{0, 0, 1, 0, 1, 1, 0, 1}; else if (face == Face.BOTTOM) return new float[]{0, 0, 1, 0, 1, 1, 0, 1}; else return new float[]{0, 0, 1, 0, 1, 1, 0, 1}; default: return new float[]{0, 0, 1, 0, 1, 1, 0, 1}; } } private float[] getColor(Voxel voxel) { // Simple color mapping switch (voxel.getType()) { case Voxel.TYPE_GRASS: return new float[]{0.2f, 0.8f, 0.2f}; case Voxel.TYPE_DIRT: return new float[]{0.5f, 0.3f, 0.1f}; case Voxel.TYPE_STONE: return new float[]{0.5f, 0.5f, 0.5f}; case Voxel.TYPE_WATER: return new float[]{0.2f, 0.2f, 0.8f}; case Voxel.TYPE_WOOD: return new float[]{0.5f, 0.3f, 0.1f}; case Voxel.TYPE_LEAVES: return new float[]{0.1f, 0.6f, 0.1f}; default: return new float[]{1.0f, 1.0f, 1.0f}; } } private void createBuffers(List<Float> vertices, List<Integer> indices) { vertexBuffer = BufferUtils.createFloatBuffer(vertices.size()); for (Float v : vertices) { vertexBuffer.put(v); } vertexBuffer.flip(); indexBuffer = BufferUtils.createIntBuffer(indices.size()); for (Integer i : indices) { indexBuffer.put(i); } indexBuffer.flip(); } public void render() { if (vertexCount == 0) return; // Enable vertex arrays glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); // Set pointers glVertexPointer(3, GL_FLOAT, VERTEX_SIZE * Float.BYTES, vertexBuffer); glTexCoordPointer(2, GL_FLOAT, VERTEX_SIZE * Float.BYTES, vertexBuffer.position(3)); glColorPointer(3, GL_FLOAT, VERTEX_SIZE * Float.BYTES, vertexBuffer.position(5)); // Draw glDrawElements(GL_TRIANGLES, indexBuffer); // Disable vertex arrays glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); } public void cleanup() { // Clean up buffers if (vertexBuffer != null) { vertexBuffer.clear(); } if (indexBuffer != null) { indexBuffer.clear(); } } } enum Face { TOP, BOTTOM, NORTH, SOUTH, EAST, WEST; public float[] getVertices(float x, float y, float z) { switch (this) { case TOP: return new float[]{ x, y + 1, z, // 0 x + 1, y + 1, z, // 1 x + 1, y + 1, z + 1,// 2 x, y + 1, z + 1 // 3 }; case BOTTOM: return new float[]{ x, y, z, // 0 x, y, z + 1, // 1 x + 1, y, z + 1, // 2 x + 1, y, z // 3 }; case NORTH: return new float[]{ x, y, z, // 0 x, y + 1, z, // 1 x + 1, y + 1, z, // 2 x + 1, y, z // 3 }; case SOUTH: return new float[]{ x, y, z + 1, // 0 x + 1, y, z + 1, // 1 x + 1, y + 1, z + 1,// 2 x, y + 1, z + 1 // 3 }; case EAST: return new float[]{ x + 1, y, z, // 0 x + 1, y + 1, z, // 1 x + 1, y + 1, z + 1,// 2 x + 1, y, z + 1 // 3 }; case WEST: return new float[]{ x, y, z, // 0 x, y, z + 1, // 1 x, y + 1, z + 1, // 2 x, y + 1, z // 3 }; default: return new float[12]; } } public int[] getIndices() { return new int[]{0, 1, 2, 0, 2, 3}; } }

World Management

World Class

public class VoxelWorld { private final Map<Long, Chunk> chunks; private final int renderDistance; private final WorldGenerator worldGenerator; public VoxelWorld(int renderDistance) { this.chunks = new ConcurrentHashMap<>(); this.renderDistance = renderDistance; this.worldGenerator = new WorldGenerator(); } public Chunk getChunk(int chunkX, int chunkZ) { long key = getChunkKey(chunkX, chunkZ); return chunks.computeIfAbsent(key, k -> { Chunk chunk = new Chunk(chunkX, chunkZ); worldGenerator.generateChunk(chunk); return chunk; }); } public Voxel getVoxel(int worldX, int worldY, int worldZ) { int chunkX = worldX >> 4; // Divide by 16 int chunkZ = worldZ >> 4; int localX = worldX & 0xF; // Modulo 16 int localZ = worldZ & 0xF; Chunk chunk = getChunk(chunkX, chunkZ); return chunk.getVoxel(localX, worldY, localZ); } public void setVoxel(int worldX, int worldY, int worldZ, Voxel voxel) { int chunkX = worldX >> 4; int chunkZ = worldZ >> 4; int localX = worldX & 0xF; int localZ = worldZ & 0xF; Chunk chunk = getChunk(chunkX, chunkZ); chunk.setVoxel(localX, worldY, localZ, voxel); } public void updateChunks(int playerChunkX, int playerChunkZ) { // Load chunks within render distance for (int x = -renderDistance; x <= renderDistance; x++) { for (int z = -renderDistance; z <= renderDistance; z++) { int chunkX = playerChunkX + x; int chunkZ = playerChunkZ + z; getChunk(chunkX, chunkZ); // This will generate if needed } } // Unload chunks outside render distance chunks.entrySet().removeIf(entry -> { long key = entry.getKey(); int chunkX = (int)(key >> 32); int chunkZ = (int)(key & 0xFFFFFFFF); int distX = Math.abs(chunkX - playerChunkX); int distZ = Math.abs(chunkZ - playerChunkZ); return distX > renderDistance || distZ > renderDistance; }); } public void render() { for (Chunk chunk : chunks.values()) { ChunkMesh mesh = chunk.getMesh(); if (mesh != null) { glPushMatrix(); glTranslatef(chunk.getChunkX() * Chunk.CHUNK_SIZE, 0, chunk.getChunkZ() * Chunk.CHUNK_SIZE); mesh.render(); glPopMatrix(); } } } private long getChunkKey(int x, int z) { return ((long)x << 32) | (z & 0xFFFFFFFFL); } public void cleanup() { for (Chunk chunk : chunks.values()) { ChunkMesh mesh = chunk.getMesh(); if (mesh != null) { mesh.cleanup(); } } chunks.clear(); } }

World Generation

Procedural World Generator

public class WorldGenerator { private final SimplexNoise terrainNoise; private final SimplexNoise caveNoise; private final Random random; public WorldGenerator() { this.random = new Random(); this.terrainNoise = new SimplexNoise(12345); this.caveNoise = new SimplexNoise(67890); } public void generateChunk(Chunk chunk) { int chunkX = chunk.getChunkX(); int chunkZ = chunk.getChunkZ(); for (int x = 0; x < Chunk.CHUNK_SIZE; x++) { for (int z = 0; z < Chunk.CHUNK_SIZE; z++) { int worldX = chunk.getWorldX(x); int worldZ = chunk.getWorldZ(z); generateColumn(chunk, x, z, worldX, worldZ); } } } private void generateColumn(Chunk chunk, int x, int z, int worldX, int worldZ) { // Generate terrain height double noise = terrainNoise.noise(worldX * 0.01, worldZ * 0.01); double roughness = terrainNoise.noise(worldX * 0.05, worldZ * 0.05) * 0.3; int height = (int)((noise * 0.5 + 0.5) * 30 + roughness * 10 + 50); // Generate caves boolean hasCave = caveNoise.noise(worldX * 0.1, worldZ * 0.1) > 0.2; for (int y = 0; y < Chunk.CHUNK_HEIGHT; y++) { Voxel voxel = determineVoxel(y, height, hasCave, worldX, worldZ, y); chunk.setVoxel(x, y, z, voxel); } } private Voxel determineVoxel(int y, int surfaceHeight, boolean hasCave, int worldX, int worldZ, int localY) { if (y > surfaceHeight) { if (y < 60) return Voxel.water(); return Voxel.air(); } // Generate caves if (hasCave && y < surfaceHeight - 5 && y > 10) { double caveNoise = caveNoise.noise(worldX * 0.2, localY * 0.2, worldZ * 0.2); if (caveNoise > 0.1) { return Voxel.air(); } } // Surface layers if (y == surfaceHeight) { return Voxel.grass(); } else if (y > surfaceHeight - 5) { return Voxel.dirt(); } else if (y > surfaceHeight - 15) { // Occasionally generate ore veins if (random.nextFloat() < 0.02f) { return Voxel.stone(); // In real implementation, this would be an ore type } return Voxel.stone(); } else { return Voxel.stone(); } } public void generateTree(Chunk chunk, int x, int y, int z) { // Generate trunk int trunkHeight = 4 + random.nextInt(3); for (int i = 0; i < trunkHeight; i++) { if (y + i < Chunk.CHUNK_HEIGHT) { chunk.setVoxel(x, y + i, z, Voxel.wood()); } } // Generate leaves int leafStart = y + trunkHeight - 2; for (int dx = -2; dx <= 2; dx++) { for (int dz = -2; dz <= 2; dz++) { for (int dy = 0; dy < 3; dy++) { if (Math.abs(dx) + Math.abs(dz) + Math.abs(dy) <= 3) { int leafX = x + dx; int leafY = leafStart + dy; int leafZ = z + dz; if (leafX >= 0 && leafX < Chunk.CHUNK_SIZE && leafZ >= 0 && leafZ < Chunk.CHUNK_SIZE && leafY < Chunk.CHUNK_HEIGHT) { chunk.setVoxel(leafX, leafY, leafZ, Voxel.leaves()); } } } } } } } // Simple Simplex Noise implementation public class SimplexNoise { private final PermutationTable permutation; public SimplexNoise(long seed) { this.permutation = new PermutationTable(seed); } public double noise(double x, double y) { // 2D Simplex noise implementation // Simplified version - full implementation would be more complex double s = (x + y) * 0.366025403784439; // F2 int i = (int)Math.floor(x + s); int j = (int)Math.floor(y + s); double t = (i + j) * 0.211324865405187; // G2 double X0 = i - t; double Y0 = j - t; double x0 = x - X0; double y0 = y - Y0; // Determine which simplex we're in int i1, j1; if (x0 > y0) { i1 = 1; j1 = 0; } else { i1 = 0; j1 = 1; } double x1 = x0 - i1 + 0.211324865405187; double y1 = y0 - j1 + 0.211324865405187; double x2 = x0 - 1.0 + 0.422649730810374; double y2 = y0 - 1.0 + 0.422649730810374; // Calculate contributions double n0, n1, n2; double t0 = 0.5 - x0 * x0 - y0 * y0; if (t0 < 0) n0 = 0; else { t0 *= t0; n0 = t0 * t0 * grad(permutation.perm(i, j), x0, y0); } double t1 = 0.5 - x1 * x1 - y1 * y1; if (t1 < 0) n1 = 0; else { t1 *= t1; n1 = t1 * t1 * grad(permutation.perm(i + i1, j + j1), x1, y1); } double t2 = 0.5 - x2 * x2 - y2 * y2; if (t2 < 0) n2 = 0; else { t2 *= t2; n2 = t2 * t2 * grad(permutation.perm(i + 1, j + 1), x2, y2); } return 70.0 * (n0 + n1 + n2); } public double noise(double x, double y, double z) { // 3D Simplex noise - similar structure but more complex // Implementation would follow similar pattern to 2D but with 3 dimensions return noise(x, y); // Simplified for prototype } private double grad(int hash, double x, double y) { int h = hash & 7; double u = h < 4 ? x : y; double v = h < 4 ? y : x; return ((h & 1) != 0 ? -u : u) + ((h & 2) != 0 ? -2.0 * v : 2.0 * v); } private static class PermutationTable { private final int[] perm; public PermutationTable(long seed) { perm = new int[512]; Random random = new Random(seed); int[] p = new int[256]; for (int i = 0; i < 256; i++) p[i] = i; // Shuffle array for (int i = 0; i < 256; i++) { int j = random.nextInt(256 - i) + i; int temp = p[i]; p[i] = p[j]; p[j] = temp; } // Duplicate for overflow for (int i = 0; i < 512; i++) { perm[i] = p[i & 255]; } } public int perm(int x, int y) { return perm[perm[x] + y]; } public int perm(int x, int y, int z) { return perm[perm[perm[x] + y] + z]; } } }

Player and Camera System

First-Person Camera

public class Player { private Vector3f position; private Vector3f velocity; private float yaw, pitch; private boolean onGround; private final AABB boundingBox; public Player() { this.position = new Vector3f(0, 70, 0); this.velocity = new Vector3f(0, 0, 0); this.boundingBox = new AABB(-0.3f, 0, -0.3f, 0.3f, 1.8f, 0.3f); } public void update(float deltaTime, VoxelWorld world) { // Apply gravity if (!onGround) { velocity.y -= 20.0f * deltaTime; // Gravity } // Update position Vector3f newPosition = new Vector3f(position); newPosition.x += velocity.x * deltaTime; newPosition.y += velocity.y * deltaTime; newPosition.z += velocity.z * deltaTime; // Check collisions handleCollisions(world, newPosition); // Apply friction velocity.x *= 0.9f; velocity.z *= 0.9f; } private void handleCollisions(VoxelWorld world, Vector3f newPosition) { AABB newBoundingBox = boundingBox.translate(newPosition); // Check Y collision (vertical) if (velocity.y < 0) { // Falling if (checkCollision(world, newBoundingBox.offset(0, -0.1f, 0))) { velocity.y = 0; onGround = true; newPosition.y = (float)Math.floor(newPosition.y); } else { onGround = false; } } else if (velocity.y > 0) { // Jumping if (checkCollision(world, newBoundingBox.offset(0, 0.1f, 0))) { velocity.y = 0; } } // Check X collision if (checkCollision(world, newBoundingBox.offset(velocity.x * 0.1f, 0, 0))) { velocity.x = 0; } // Check Z collision if (checkCollision(world, newBoundingBox.offset(0, 0, velocity.z * 0.1f))) { velocity.z = 0; } position.set(newPosition); } private boolean checkCollision(VoxelWorld world, AABB box) { int minX = (int)Math.floor(box.minX); int maxX = (int)Math.ceil(box.maxX); int minY = (int)Math.floor(box.minY); int maxY = (int)Math.ceil(box.maxY); int minZ = (int)Math.floor(box.minZ); int maxZ = (int)Math.ceil(box.maxZ); for (int x = minX; x <= maxX; x++) { for (int y = minY; y <= maxY; y++) { for (int z = minZ; z <= maxZ; z++) { Voxel voxel = world.getVoxel(x, y, z); if (voxel.isSolid()) { AABB voxelBox = new AABB(x, y, z, x + 1, y + 1, z + 1); if (box.intersects(voxelBox)) { return true; } } } } } return false; } public void move(float forward, float strafe) { float cosYaw = (float)Math.cos(Math.toRadians(yaw)); float sinYaw = (float)Math.sin(Math.toRadians(yaw)); velocity.x = forward * sinYaw + strafe * cosYaw; velocity.z = -forward * cosYaw + strafe * sinYaw; // Normalize if moving diagonally if (forward != 0 && strafe != 0) { velocity.x *= 0.707f; velocity.z *= 0.707f; } // Apply speed float speed = 5.0f; velocity.x *= speed; velocity.z *= speed; } public void jump() { if (onGround) { velocity.y = 8.0f; onGround = false; } } public void setOrientation(float yaw, float pitch) { this.yaw = yaw; this.pitch = Math.max(-89, Math.min(89, pitch)); } public Matrix4f getViewMatrix() { Matrix4f matrix = new Matrix4f(); matrix.setIdentity(); matrix.rotate((float)Math.toRadians(pitch), new Vector3f(1, 0, 0)); matrix.rotate((float)Math.toRadians(yaw), new Vector3f(0, 1, 0)); matrix.translate(new Vector3f(-position.x, -position.y, -position.z)); return matrix; } // Getters public Vector3f getPosition() { return position; } public float getYaw() { return yaw; } public float getPitch() { return pitch; } } public class AABB { public final float minX, minY, minZ; public final float maxX, maxY, maxZ; public AABB(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { this.minX = minX; this.minY = minY; this.minZ = minZ; this.maxX = maxX; this.maxY = maxY; this.maxZ = maxZ; } public AABB translate(Vector3f translation) { return new AABB( minX + translation.x, minY + translation.y, minZ + translation.z, maxX + translation.x, maxY + translation.y, maxZ + translation.z ); } public AABB offset(float dx, float dy, float dz) { return new AABB(minX + dx, minY + dy, minZ + dz, maxX + dx, maxY + dy, maxZ + dz); } public boolean intersects(AABB other) { return minX < other.maxX && maxX > other.minX && minY < other.maxY && maxY > other.minY && minZ < other.maxZ && maxZ > other.minZ; } }

Main Game Loop

Voxel Engine Main Class

public class VoxelEngine { private VoxelWorld world; private Player player; private boolean running; private int windowWidth = 800; private int windowHeight = 600; public VoxelEngine() { try { initialize(); run(); } finally { cleanup(); } } private void initialize() { // Initialize GLFW if (!glfwInit()) { throw new IllegalStateException("Unable to initialize GLFW"); } // Create window long window = glfwCreateWindow(windowWidth, windowHeight, "Voxel Engine", 0, 0); if (window == 0) { throw new RuntimeException("Failed to create GLFW window"); } glfwMakeContextCurrent(window); GL.createCapabilities(); // Initialize systems world = new VoxelWorld(8); // 8 chunk render distance player = new Player(); // Set up OpenGL glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); // Set up callbacks setupCallbacks(window); running = true; } private void setupCallbacks(long window) { glfwSetKeyCallback(window, (win, key, scancode, action, mods) -> { if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) { running = false; } }); glfwSetCursorPosCallback(window, (win, xpos, ypos) -> { handleMouseInput(xpos, ypos); }); glfwSetMouseButtonCallback(window, (win, button, action, mods) -> { handleMouseClick(button, action); }); } private void handleMouseInput(double xpos, double ypos) { // Calculate mouse movement float deltaX = (float)(xpos - windowWidth / 2); float deltaY = (float)(ypos - windowHeight / 2); // Update player orientation player.setOrientation( player.getYaw() + deltaX * 0.1f, player.getPitch() + deltaY * 0.1f ); // Reset cursor to center glfwSetCursorPos(glfwGetCurrentContext(), windowWidth / 2, windowHeight / 2); } private void handleMouseClick(int button, int action) { if (action == GLFW_PRESS) { if (button == GLFW_MOUSE_BUTTON_LEFT) { // Break block breakBlock(); } else if (button == GLFW_MOUSE_BUTTON_RIGHT) { // Place block placeBlock(); } } } private void breakBlock() { Vector3f position = player.getPosition(); Vector3f direction = getLookDirection(); // Raycast to find targeted block for (float t = 0; t < 5; t += 0.1f) { int x = (int)Math.floor(position.x + direction.x * t); int y = (int)Math.floor(position.y + direction.y * t); int z = (int)Math.floor(position.z + direction.z * t); Voxel voxel = world.getVoxel(x, y, z); if (voxel.isSolid()) { world.setVoxel(x, y, z, Voxel.air()); break; } } } private void placeBlock() { Vector3f position = player.getPosition(); Vector3f direction = getLookDirection(); // Raycast to find placement position Integer lastX = null, lastY = null, lastZ = null; for (float t = 0; t < 5; t += 0.1f) { int x = (int)Math.floor(position.x + direction.x * t); int y = (int)Math.floor(position.y + direction.y * t); int z = (int)Math.floor(position.z + direction.z * t); Voxel voxel = world.getVoxel(x, y, z); if (voxel.isSolid()) { if (lastX != null) { // Place block at previous position (adjacent to hit block) world.setVoxel(lastX, lastY, lastZ, Voxel.stone()); } break; } lastX = x; lastY = y; lastZ = z; } } private Vector3f getLookDirection() { float yaw = (float)Math.toRadians(player.getYaw()); float pitch = (float)Math.toRadians(player.getPitch()); return new Vector3f( (float)(Math.sin(yaw) * Math.cos(pitch)), (float)(-Math.sin(pitch)), (float)(-Math.cos(yaw) * Math.cos(pitch)) ); } private void run() { long window = glfwGetCurrentContext(); long lastTime = System.nanoTime(); while (running && !glfwWindowShouldClose(window)) { long currentTime = System.nanoTime(); float deltaTime = (currentTime - lastTime) / 1_000_000_000.0f; lastTime = currentTime; // Handle input handleKeyboardInput(window, deltaTime); // Update update(deltaTime); // Render render(); glfwSwapBuffers(window); glfwPollEvents(); } } private void handleKeyboardInput(long window, float deltaTime) { float forward = 0, strafe = 0; if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) forward += 1; if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) forward -= 1; if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) strafe -= 1; if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) strafe += 1; if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) player.jump(); player.move(forward, strafe); } private void update(float deltaTime) { player.update(deltaTime, world); // Update chunks around player Vector3f playerPos = player.getPosition(); int playerChunkX = (int)Math.floor(playerPos.x) >> 4; int playerChunkZ = (int)Math.floor(playerPos.z) >> 4; world.updateChunks(playerChunkX, playerChunkZ); } private void render() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Set up projection matrix Matrix4f projection = new Matrix4f(); projection.perspective((float)Math.toRadians(70), (float)windowWidth / windowHeight, 0.1f, 1000.0f); // Set up view matrix from player Matrix4f view = player.getViewMatrix(); // Set up model-view-projection matrix Matrix4f mvp = new Matrix4f(projection); mvp.mul(view); // Render world glLoadMatrixf(mvp.get(new float[16])); world.render(); } private void cleanup() { if (world != null) { world.cleanup(); } glfwTerminate(); } public static void main(String[] args) { new VoxelEngine(); } }

Performance Optimizations

Frustum Culling and LOD

public class ChunkManager { private final VoxelWorld world; private final Map<Long, Chunk> loadedChunks; private final List<Chunk> visibleChunks; public ChunkManager(VoxelWorld world) { this.world = world; this.loadedChunks = new HashMap<>(); this.visibleChunks = new ArrayList<>(); } public void updateVisibility(Frustum frustum, Vector3f cameraPos) { visibleChunks.clear(); for (Chunk chunk : loadedChunks.values()) { AABB chunkBounds = getChunkAABB(chunk); if (frustum.intersects(chunkBounds)) { // Calculate distance for LOD float distance = distanceToChunk(cameraPos, chunk); // Simple LOD: skip meshing for distant chunks if (distance < 100) { // Only mesh chunks within 100 units visibleChunks.add(chunk); } } } } private AABB getChunkAABB(Chunk chunk) { float minX = chunk.getChunkX() * Chunk.CHUNK_SIZE; float minZ = chunk.getChunkZ() * Chunk.CHUNK_SIZE; float maxX = minX + Chunk.CHUNK_SIZE; float maxZ = minZ + Chunk.CHUNK_SIZE; return new AABB(minX, 0, minZ, maxX, Chunk.CHUNK_HEIGHT, maxZ); } private float distanceToChunk(Vector3f cameraPos, Chunk chunk) { float chunkCenterX = (chunk.getChunkX() + 0.5f) * Chunk.CHUNK_SIZE; float chunkCenterZ = (chunk.getChunkZ() + 0.5f) * Chunk.CHUNK_SIZE; float dx = cameraPos.x - chunkCenterX; float dz = cameraPos.z - chunkCenterZ; return (float)Math.sqrt(dx * dx + dz * dz); } } public class Frustum { private final Plane[] planes; public Frustum() { this.planes = new Plane[6]; for (int i = 0; i < 6; i++) { planes[i] = new Plane(); } } public void update(Matrix4f mvp) { // Extract frustum planes from model-view-projection matrix // Left plane planes[0].set(mvp.m03 + mvp.m00, mvp.m13 + mvp.m10, mvp.m23 + mvp.m20, mvp.m33 + mvp.m30); // Right plane planes[1].set(mvp.m03 - mvp.m00, mvp.m13 - mvp.m10, mvp.m23 - mvp.m20, mvp.m33 - mvp.m30); // Bottom plane planes[2].set(mvp.m03 + mvp.m01, mvp.m13 + mvp.m11, mvp.m23 + mvp.m21, mvp.m33 + mvp.m31); // Top plane planes[3].set(mvp.m03 - mvp.m01, mvp.m13 - mvp.m11, mvp.m23 - mvp.m21, mvp.m33 - mvp.m31); // Near plane planes[4].set(mvp.m03 + mvp.m02, mvp.m13 + mvp.m12, mvp.m23 + mvp.m22, mvp.m33 + mvp.m32); // Far plane planes[5].set(mvp.m03 - mvp.m02, mvp.m13 - mvp.m12, mvp.m23 - mvp.m22, mvp.m33 - mvp.m32); // Normalize all planes for (Plane plane : planes) { plane.normalize(); } } public boolean intersects(AABB aabb) { for (Plane plane : planes) { if (plane.distanceToPoint(getPositiveVertex(aabb, plane)) < 0) { return false; } } return true; } private Vector3f getPositiveVertex(AABB aabb, Plane plane) { Vector3f vertex = new Vector3f(); vertex.x = plane.normal.x > 0 ? aabb.maxX : aabb.minX; vertex.y = plane.normal.y > 0 ? aabb.maxY : aabb.minY; vertex.z = plane.normal.z > 0 ? aabb.maxZ : aabb.minZ; return vertex; } } public class Plane { public float a, b, c, d; public void set(float a, float b, float c, float d) { this.a = a; this.b = b; this.c = c; this.d = d; } public void normalize() { float length = (float)Math.sqrt(a * a + b * b + c * c); if (length > 0) { float invLength = 1.0f / length; a *= invLength; b *= invLength; c *= invLength; d *= invLength; } } public float distanceToPoint(Vector3f point) { return a * point.x + b * point.y + c * point.z + d; } }

This voxel engine prototype provides a solid foundation for building Minecraft-like games or other voxel-based applications. Key features include chunk-based world management, greedy meshing for efficient rendering, procedural world generation, collision detection, and basic player interaction. The architecture is designed to be extensible for adding features like lighting, fluids, and more advanced world generation.