sebastian/Dicewars-Java-Approach
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

finished game-engine-terrain-generation #2

Merged
sebastian merged 9 commits from game-engine-terrain-generation into game-engine 2023-10-05 14:00:29 +02:00
Conversation 0 Commits 9 Files Changed 14 +75 -103
5 changed files with 75 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit e0afd6e93a - Show all commits

11
client/src/main/java/core/engine/Engine.java
View File

@ -118,7 +118,7 @@ public class Engine {
glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
Camera camera = new Camera();
input(camera);
Light light = new Light(new Vector3f(0,0,-20), new Vector3f(1,1,1));
RawModel model = OBJLoader.loadOBJModel("dragon", loader);
@ -127,11 +127,12 @@ public class Engine {
Entity entity = new Entity(texturedModel, new Vector3f(0,0,-50), 0,0,0,1);
//Generate Simple, Flat Terrain
Terrain terrain = new Terrain(0,0, loader, new ModelTexture(loader.loadTexture("grass")));
Terrain terrain = new Terrain( loader, new ModelTexture(loader.loadTexture("grass")));
// Run the rendering loop until the user has attempted to close
// the window or has pressed the ESCAPE key.
MasterRenderer renderer = new MasterRenderer();
input(camera, renderer);
while ( !glfwWindowShouldClose(window) ) {
//entity.increaseRotation(0,1,0);
renderer.processTerrain(terrain);
@ -146,7 +147,7 @@ public class Engine {
loader.cleanUp();
}
private void input(Camera camera) {
private void input(Camera camera, MasterRenderer masterRenderer) {
GLFWScrollCallback glfwScrollCallback = new GLFWScrollCallback() {
@Override
@ -226,6 +227,10 @@ public class Engine {
if(key == GLFW_KEY_S) {
camera.moveBackward();
}
if(key == GLFW_KEY_Y && action == GLFW_PRESS) {
masterRenderer.switchWireframe();
}
}
});

12
client/src/main/java/core/engine/renderer/MasterRenderer.java
View File

@ -31,6 +31,8 @@ public class MasterRenderer {
private List<TerrainTile> terrains = new ArrayList<>();
private Matrix4f projectionMatrix;
private boolean wireframe = false;
public MasterRenderer() {
GL11.glEnable(GL11.GL_CULL_FACE);
GL11.glCullFace(GL11.GL_BACK);
@ -98,4 +100,14 @@ public class MasterRenderer {
projectionMatrix.m33 = 0;
}
public void switchWireframe() {
this.wireframe = !this.wireframe;
if(this.wireframe) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
} else {
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
}
}

30
client/src/main/java/core/engine/terrain/Terrain.java
View File

@ -9,40 +9,18 @@ import java.util.List;
public class Terrain {
private static final float SIZE = 100;
private static final int VERTEX_COUNT = 128;
private float x;
private float z;
private List<TerrainTile> terrainTiles = new ArrayList<>();
public Terrain(int gridX, int gridZ, Loader loader, ModelTexture modelTexture) {
this.x = gridX * SIZE;
this.z = gridZ * SIZE;
for (int row = 0; row < VERTEX_COUNT - 1; row++) {
for (int column = 0; column < VERTEX_COUNT - 1; column++) {
TerrainTile terrainTile = new TerrainTile(loader, modelTexture, row, column, VERTEX_COUNT, SIZE);
terrainTiles.add(terrainTile);
public Terrain(Loader loader, ModelTexture modelTexture) {
for(int i=0; i<32; i++) {
for(int j=0; j<32; j++) {
terrainTiles.add(new TerrainTile(i, j, loader, modelTexture));
}
}
}
public float getX() {
return x;
}
public float getZ() {
return z;
}
public List<TerrainTile> getTerrainTiles() {
return terrainTiles;
}
public void setTerrainTiles(List<TerrainTile> terrainTiles) {
this.terrainTiles = terrainTiles;
}
}

5
client/src/main/java/core/engine/terrain/TerrainGenerator.java
View File

@ -1,5 +0,0 @@
package core.engine.terrain;
public class TerrainGenerator {
}

118
client/src/main/java/core/engine/terrain/TerrainTile.java
View File

@ -2,101 +2,83 @@ package core.engine.terrain;
import core.engine.Loader;
import core.engine.model.RawModel;
import core.engine.model.TexturedModel;
import core.engine.textures.ModelTexture;
public class TerrainTile {
private RawModel model;
private ModelTexture texture;
private static final float SIZE = 32;
private static final int VERTEX_COUNT = 33;
private float x;
private float z;
private RawModel model;
private ModelTexture texture;
public TerrainTile(Loader loader, ModelTexture texture, int row, int column, int VERTEX_COUNT, float size) {
float[] vertices = new float[12]; // 4 vertices * 3 coordinates
float[] normals = new float[12]; // 4 normals * 3 coordinates
float[] textureCoords = new float[8]; // 4 texture coords * 2 coordinates
int[] indices = new int[6]; // 2 triangles * 3 indices
//Calculate positions for the four vertices of this terrain tile
float x0 = (float) column / (VERTEX_COUNT - 1) * size;
float x1 = (float) (column + 1) / (VERTEX_COUNT - 1) * size;
float z0 = (float) row / (VERTEX_COUNT - 1) * size;
float z1 = (float) (row + 1) / (VERTEX_COUNT - 1) * size;
// Populate vertices, normals, and textureCoords arrays based on the calculated positions
//Vertices
// Vertex 0
vertices[0] = x0;
vertices[1] = 0;
vertices[2] = z0;
// Vertex 1
vertices[3] = x0;
vertices[4] = 0;
vertices[5] = z1;
// Vertex 2
vertices[6] = x1;
vertices[7] = 0;
vertices[8] = z0;
// Vertex 3
vertices[9] = x1;
vertices[10] = 0;
vertices[11] = z1;
//Normals
for(int i=0; i<normals.length/3; i++) {
normals[i*3] = 0;
normals[i*3+1] = 1;
normals[i*3+2] = 2;
}
// Define indices for the triangles
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
indices[3] = 2;
indices[4] = 1;
indices[5] = 3;
this.model = loader.loadToVAO(vertices, textureCoords, normals, indices);
public TerrainTile(int gridX, int gridZ, Loader loader, ModelTexture texture) {
this.x = gridX;
this.z = gridZ;
this.texture = texture;
this.model = generateTerrain(loader);
}
this.x = x0;
this.z = z0;
private RawModel generateTerrain(Loader loader) {
int count = VERTEX_COUNT * VERTEX_COUNT;
float[] vertices = new float[count * 3];
float[] normals = new float[count * 3];
float[] textureCoords = new float[count*2];
int[] indices = new int[6*(VERTEX_COUNT-1)*(VERTEX_COUNT-1)];
int vertexPointer = 0;
for(int i=0;i<VERTEX_COUNT;i++){
for(int j=0;j<VERTEX_COUNT;j++){
vertices[vertexPointer*3] = (float)j/((float)VERTEX_COUNT - 1) * SIZE;
vertices[vertexPointer*3+1] = 0;
vertices[vertexPointer*3+2] = (float)i/((float)VERTEX_COUNT - 1) * SIZE;
normals[vertexPointer*3] = 0;
normals[vertexPointer*3+1] = 1;
normals[vertexPointer*3+2] = 0;
textureCoords[vertexPointer*2] = (float)j/((float)VERTEX_COUNT - 1);
textureCoords[vertexPointer*2+1] = (float)i/((float)VERTEX_COUNT - 1);
vertexPointer++;
}
}
int pointer = 0;
for(int gz=0;gz<VERTEX_COUNT-1;gz++){
for(int gx=0;gx<VERTEX_COUNT-1;gx++){
int topLeft = (gz*VERTEX_COUNT)+gx;
int topRight = topLeft + 1;
int bottomLeft = ((gz+1)*VERTEX_COUNT)+gx;
int bottomRight = bottomLeft + 1;
indices[pointer++] = topLeft;
indices[pointer++] = bottomLeft;
indices[pointer++] = topRight;
indices[pointer++] = topRight;
indices[pointer++] = bottomLeft;
indices[pointer++] = bottomRight;
}
}
return loader.loadToVAO(vertices, textureCoords, normals, indices);
}
public RawModel getModel() {
return model;
}
public void setModel(RawModel model) {
this.model = model;
}
public ModelTexture getTexture() {
return texture;
}
public void setTexture(ModelTexture texture) {
this.texture = texture;
}
public float getX() {
return x;
}
public void setX(float x) {
this.x = x;
}
public float getZ() {
return z;
}
public void setZ(float z) {
this.z = z;
}
// Getters and setters for the model, x, and z
}