halotroop
/
Ginger3D
1
0
Fork 0
Code Pull Requests Packages Releases Activity

[Deprecation] Removed (unused) deprecated terrain

pull/12/head
Caroline Bell 2020-02-27 18:46:49 -08:00
parent 9e5a3d17ba
commit bb192e0710
6 changed files with 7 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/com/github/hydos/ginger/engine/api/Ginger.java
View File

@ -83,7 +83,7 @@ public class Ginger
{
GingerUtils.preRenderScene(gingerRegister.masterRenderer);
contrastFbo.bindFBO();
gingerRegister.masterRenderer.renderSceneNoTerrain(game.data.entities, game.data.normalMapEntities, game.data.lights, game.data.camera, game.data.clippingPlane, world);
gingerRegister.masterRenderer.renderScene(game.data.entities, game.data.normalMapEntities, game.data.lights, game.data.camera, game.data.clippingPlane, world);
ParticleMaster.renderParticles(game.data.camera);
contrastFbo.unbindFBO();
PostProcessing.doPostProcessing(contrastFbo.colorTexture);
@ -104,7 +104,7 @@ public class Ginger
timer.addTickListener(gameTickListener);
contrastFbo = new Fbo(new ContrastChanger());
gingerRegister.masterRenderer = masterRenderer;
picker = new MousePicker(game.data.camera, masterRenderer.getProjectionMatrix(), null);
picker = new MousePicker(game.data.camera, masterRenderer.getProjectionMatrix());
PostProcessing.init();
ParticleMaster.init(masterRenderer.getProjectionMatrix());
}

3
src/main/java/com/github/hydos/ginger/engine/api/game/GameData.java
View File

@ -7,7 +7,6 @@ import org.joml.Vector4f;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.elements.GuiTexture;
import com.github.hydos.ginger.engine.elements.objects.*;
import com.github.hydos.ginger.engine.terrain.Terrain;
/*
* Used for storing essential engine game data so main class isn't messy
@ -19,7 +18,6 @@ public class GameData
public List<RenderObject> entities;
public List<Light> lights;
public List<RenderObject> normalMapEntities;
public List<Terrain> flatTerrains;
public Player player;
public Camera camera;
public Vector4f clippingPlane;
@ -33,7 +31,6 @@ public class GameData
entities = new ArrayList<RenderObject>();
lights = new ArrayList<Light>();
normalMapEntities = new ArrayList<RenderObject>();
flatTerrains = new ArrayList<Terrain>();
this.player = player;
this.camera = camera;
this.tickSpeed = tickSpeed;

3
src/main/java/com/github/hydos/ginger/engine/math/matrixes/Matrix3f.java
View File

@ -252,8 +252,7 @@ public class Matrix3f extends Matrix implements Serializable
* @return the destination vector */
public static Vector3f transform(Matrix3f left, Vector3f right, Vector3f dest)
{
if (dest == null)
dest = new Vector3f();
if (dest == null) dest = new Vector3f();
float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z;
float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z;
float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z;

15
src/main/java/com/github/hydos/ginger/engine/render/MasterRenderer.java
View File

@ -16,7 +16,6 @@ import com.github.hydos.ginger.engine.render.models.TexturedModel;
import com.github.hydos.ginger.engine.render.renderers.*;
import com.github.hydos.ginger.engine.render.shaders.*;
import com.github.hydos.ginger.engine.shadow.ShadowMapMasterRenderer;
import com.github.hydos.ginger.engine.terrain.Terrain;
public class MasterRenderer
{
@ -159,16 +158,7 @@ public class MasterRenderer
normalRenderer.render(normalMapEntities, clipPlane, lights, camera);
}
public void renderScene(List<RenderObject> entities, List<RenderObject> normalEntities, List<Terrain> terrains, List<Light> lights, Camera camera, Vector4f clipPlane)
{
prepare();
renderEntities(entities, camera, lights);
renderNormalEntities(normalEntities, lights, camera, clipPlane);
renderTerrains(terrains, lights, camera);
skyboxRenderer.render(camera);
}
public void renderSceneNoTerrain(List<RenderObject> entities, List<RenderObject> normalEntities, List<Light> lights, Camera camera, Vector4f clipPlane, World world)
public void renderScene(List<RenderObject> entities, List<RenderObject> normalEntities, List<Light> lights, Camera camera, Vector4f clipPlane, World world)
{
prepare();
renderEntities(entities, camera, lights);
@ -184,7 +174,4 @@ public class MasterRenderer
shadowMapRenderer.render(entities, sun);
entities.clear();
}
private void renderTerrains(List<Terrain> terrains, List<Light> lights, Camera camera)
{}
}

27
src/main/java/com/github/hydos/ginger/engine/render/tools/MousePicker.java
View File

@ -7,7 +7,6 @@ import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.*;
import com.github.hydos.ginger.engine.terrain.Terrain;
public class MousePicker
{
@ -17,33 +16,22 @@ public class MousePicker
private Matrix4f projectionMatrix;
private Matrix4f viewMatrix;
private Camera camera;
private Terrain terrain;
private Vector3f currentTerrainPoint;
public MousePicker(Camera cam, Matrix4f projection, Terrain terrain)
public MousePicker(Camera cam, Matrix4f projection)
{
camera = cam;
projectionMatrix = projection;
viewMatrix = Maths.createViewMatrix(camera);
this.terrain = terrain;
}
private Vector3f binarySearch(int count, float start, float finish, Vector3f ray)
{
float half = start + ((finish - start) / 2f);
if (count >= RECURSION_COUNT)
{
Vector3f endPoint = getPointOnRay(ray, half);
Terrain terrain = getTerrain(endPoint.getX(), endPoint.getZ());
if (terrain != null)
{
return endPoint;
}
else
{
return null;
}
}
if (intersectionInRange(start, half, ray))
{
return binarySearch(count + 1, start, half, ray);
@ -87,9 +75,6 @@ public class MousePicker
return Vector3f.add(start, scaledRay, null);
}
private Terrain getTerrain(float worldX, float worldZ)
{ return terrain; }
private boolean intersectionInRange(float start, float finish, Vector3f ray)
{
Vector3f startPoint = getPointOnRay(ray, start);
@ -106,19 +91,9 @@ public class MousePicker
private boolean isUnderGround(Vector3f testPoint)
{
Terrain terrain = getTerrain(testPoint.getX(), testPoint.getZ());
float height = 0;
if (terrain != null)
{ height = terrain.getHeightOfTerrain(testPoint.getX(), testPoint.getZ()); }
if (testPoint.y < height)
{
return true;
}
else
{
return false;
}
}
private Vector4f toEyeCoords(Vector4f clipCoords)
{

161
src/main/java/com/github/hydos/ginger/engine/terrain/Terrain.java
View File

@ -1,161 +0,0 @@
package com.github.hydos.ginger.engine.terrain;
import java.awt.image.BufferedImage;
import java.io.IOException;
import javax.imageio.ImageIO;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.vectors.*;
import com.github.hydos.ginger.engine.render.models.RawModel;
import com.github.hydos.ginger.engine.utils.Loader;
import com.github.hydos.ginger.main.settings.Constants;
/*
* wtf
*/
@Deprecated
public class Terrain
{
private static final float MAX_PIXEL_COLOUR = 256 * 256 * 256;
private float[][] heights;
private float x, z;
private RawModel model;
private TerrainTexturePack texturePack;
private TerrainTexture blendMap;
public Terrain(float gridX, float gridZ, TerrainTexturePack texturePack, TerrainTexture blendMap, String heightMapLocation)
{
this.texturePack = texturePack;
this.blendMap = blendMap;
this.x = gridX * Constants.terrainSize;
this.z = gridZ * Constants.terrainSize;
this.model = generateTerrain(heightMapLocation);
}
private Vector3f calculateNormal(int x, int z, BufferedImage image)
{
float heightL = getHeight(x - 1, z, image);
float heightR = getHeight(x + 1, z, image);
float heightD = getHeight(x, z - 1, image);
float heightU = getHeight(x, z + 1, image);
Vector3f normal = new Vector3f(heightL - heightR, 2f, heightD - heightU);
normal.normalise();
return normal;
}
private RawModel generateTerrain(String heightMap)
{
BufferedImage image = null;
try
{
image = ImageIO.read(Terrain.class.getResourceAsStream("/textures/terrain/" + heightMap));
}
catch (IOException e)
{
e.printStackTrace();
}
int VERTEX_COUNT = image.getHeight();
heights = new float[VERTEX_COUNT][VERTEX_COUNT];
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] = j / ((float) VERTEX_COUNT - 1) * Constants.terrainSize;
float height = getHeight(j, i, image);
heights[j][i] = height;
vertices[vertexPointer * 3 + 1] = height;
vertices[vertexPointer * 3 + 2] = i / ((float) VERTEX_COUNT - 1) * Constants.terrainSize;
Vector3f normal = calculateNormal(j, i, image);
normals[vertexPointer * 3] = normal.x;
normals[vertexPointer * 3 + 1] = normal.y;
normals[vertexPointer * 3 + 2] = normal.z;
textureCoords[vertexPointer * 2] = j / ((float) VERTEX_COUNT - 1);
textureCoords[vertexPointer * 2 + 1] = 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, indices, normals, textureCoords);
}
public TerrainTexture getBlendMap()
{ return blendMap; }
private float getHeight(int x, int z, BufferedImage image)
{
if (x < 0 || x >= image.getHeight() || z < 0 || z >= image.getHeight())
{ return 0; }
float height = image.getRGB(x, z);
height += MAX_PIXEL_COLOUR / 2f;
height /= MAX_PIXEL_COLOUR / 2f;
height *= Constants.terrainMaxHeight;
return height;
}
public float getHeightOfTerrain(float worldX, float worldZ)
{
float terrainX = worldX - this.x;
float terrainZ = worldZ - this.z;
float gridSquareSize = Constants.terrainSize / ((float) heights.length - 1);
int gridX = (int) Math.floor(terrainX / gridSquareSize);
int gridZ = (int) Math.floor(terrainZ / gridSquareSize);
if (gridX >= heights.length - 1 || gridZ >= heights.length - 1 || gridX < 0 || gridZ < 0)
{ return 0; }
float xCoord = (terrainX % gridSquareSize) / gridSquareSize;
float zCoord = (terrainZ % gridSquareSize) / gridSquareSize;
float answer;
if (xCoord <= (1 - zCoord))
{
answer = Maths
.barryCentric(new Vector3f(0, heights[gridX][gridZ], 0), new Vector3f(1,
heights[gridX + 1][gridZ], 0),
new Vector3f(0,
heights[gridX][gridZ + 1], 1),
new Vector2f(xCoord, zCoord));
}
else
{
answer = Maths
.barryCentric(new Vector3f(1, heights[gridX + 1][gridZ], 0), new Vector3f(1,
heights[gridX + 1][gridZ + 1], 1),
new Vector3f(0,
heights[gridX][gridZ + 1], 1),
new Vector2f(xCoord, zCoord));
}
return answer;
}
public RawModel getModel()
{ return model; }
public TerrainTexturePack getTexturePack()
{ return texturePack; }
public float getX()
{ return x; }
public float getZ()
{ return z; }
}