refactored ground plane creation and rendering

Author: jrenner

android/assets/textures/ground1.jpg

@@ -69,15 +69,13 @@ public void loadAll() {
 			manager.load("models/gate.g3db", HeadlessModel.class, modelParam);
 			manager.load("models/strange-ramp1.g3db", HeadlessModel.class, modelParam);
 			manager.load("models/strange-ramp2.g3db", HeadlessModel.class, modelParam);
-			manager.load("models/ground.g3db", HeadlessModel.class, modelParam);
 		} else {
 			ModelLoader.ModelParameters modelParam = new ModelLoader.ModelParameters();
 			modelParam.textureParameter = modTexParam;
 
 			manager.load("models/gate.g3db", Model.class, modelParam);
 			manager.load("models/strange-ramp1.g3db", Model.class, modelParam);
 			manager.load("models/strange-ramp2.g3db", Model.class, modelParam);
-			manager.load("models/ground.g3db", Model.class, modelParam);
 			manager.load("models/skybox.g3db", Model.class, modelParam);
 		}
 
@@ -124,7 +122,7 @@ private void loadTextures() {
 		textureParam.minFilter = TextureFilter.MipMapLinearLinear;
 		textureParam.wrapU = Texture.TextureWrap.Repeat;
 		textureParam.wrapV = Texture.TextureWrap.Repeat;
-		manager.load("models/ground1.jpg", Texture.class, textureParam);
+		manager.load("textures/ground1.jpg", Texture.class, textureParam);
 		manager.load("textures/marble.jpg", Texture.class, textureParam);
 		manager.load("textures/shadow.png", Texture.class, textureParam);
 

core/src/org/jrenner/fps/Assets.java

@@ -9,6 +9,7 @@
 import com.badlogic.gdx.graphics.g3d.model.Node;
 import com.badlogic.gdx.graphics.g3d.utils.MeshPartBuilder;
 import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
+import com.badlogic.gdx.math.MathUtils;
 import com.badlogic.gdx.math.Matrix4;
 import com.badlogic.gdx.math.Quaternion;
 import com.badlogic.gdx.math.Vector3;
@@ -27,7 +28,7 @@ public class Box {
 
 
 	/** create some boxes to fill the level with some test geometry */
-	public static void createBoxes(int count, int minW, int maxW, int minH, int maxH) {
+	public static void createBoxes(int count) {
 		ModelBuilder main = new ModelBuilder();
 		ModelBuilder mb = new ModelBuilder();
 		Material material = new Material();
@@ -50,10 +51,11 @@ public static void createBoxes(int count, int minW, int maxW, int minH, int maxH
 				Model boxModel = mb.end();
 				Node node = main.node("box-" + i, boxModel);
 				node.translation.set(tmp);
+				q.idt();
+				node.rotation.set(q);
 			}
 			//node.translation.set(MathUtils.random(x), 0f, MathUtils.random(y));
 			//q.set(Vector3.X, -90);
-			q.idt();
 			mtx.set(q);
 			mtx.setTranslation(tmp);
 			btCollisionObject obj = Physics.inst.createBoxObject(tmp.set(w/2, h/2, d/2));

core/src/org/jrenner/fps/Box.java

@@ -1,8 +1,8 @@
 package org.jrenner.fps;
 
 public class GameWorld {
-	public static final int WORLD_WIDTH = 200;
-	public static final int WORLD_DEPTH = 200;
+	public static final int WORLD_WIDTH = 100;
+	public static final int WORLD_DEPTH = 100;
 	public static final int CENTER_X = WORLD_WIDTH / 2;
 	public static final int CENTER_Y = WORLD_DEPTH / 2;
 	public static final float GRAVITY = -0.01f;

core/src/org/jrenner/fps/GameWorld.java

@@ -142,7 +142,8 @@ public void changed(ChangeEvent event, Actor actor) {
 
 	private StringBuilder sb = new StringBuilder();
 
-	boolean debugHUD = false;
+	/** output extra debug info to the in-game HUD */
+	boolean debugHUD = true;
 
 	public void update() {
 		//if (Main.frame % 10 != 0) return;
@@ -179,6 +180,7 @@ public void update() {
 			sb.append("\n\nPhysics time: ").append(String.format("%4s", Main.physicsTime));
 			sb.append("\nGround dist: ").append(String.format("%.4f", player.entity.distFromGround));
 			sb.append("\nGround normal: ").append(Tools.fmt(Physics.inst.getFloorNormal(player.entity.getPosition())));
+			sb.append("\nGroundPiece visibility: ").append(View.visibleGroundPieces).append(" / ").append(View.totalGroundPieces);
 		}
 		sb.append("\nPress T to chat\nPress R to respawn");
 		label.setText(sb.toString());

core/src/org/jrenner/fps/HUD.java

@@ -36,6 +36,7 @@ public class LevelBuilder {
 
 	public static void init() {
 		staticPieces = new Array<>();
+		groundPieces = new Array<>();
 		mb = new ModelBuilder();
 		models = new Array<>();
 	}
@@ -46,45 +47,49 @@ public LevelBuilder() {
 
 	public static Array<ModelInstance> staticGeometry;
 
-	public static ModelInstance ground;
+	public static Array<ModelInstance> groundPieces;
+	public static final float groundPieceSize = 16f;
 
 	public static void createLevel() {
 		// graphical representation of the ground
 		Log.debug("createLevel - create ground");
 		if (Main.isClient()) {
-			Model groundModel = Assets.manager.get("models/ground.g3db", Model.class);
 			ModelBuilder mb = new ModelBuilder();
 			mb.begin();
-			MeshPartBuilder mpb = mb.part("first", GL20.GL_TRIANGLES, Usage.Position | Usage.Normal | Usage.TextureCoordinates, groundModel.materials.first());
 			Vector3 bl = new Vector3();
 			Vector3 tl = new Vector3();
 			Vector3 tr = new Vector3();
 			Vector3 br = new Vector3();
 			Vector3 norm = new Vector3(0f, 1f, 0f);
 			// the size of each rect that makes up the ground
-			int rectSize = 25;
-			int rectCount = 0;
-			for (int x = -100; x < GameWorld.WORLD_WIDTH; x += rectSize) {
-				if (x % 20 == 0) {
-					mpb = mb.part("section-" + x, GL20.GL_TRIANGLES, Usage.Position | Usage.Normal | Usage.TextureCoordinates, groundModel.materials.first());
-					float u1 = 0f;
-					float v1 = 0f;
-					float u2 = rectSize / 5f;
-					float v2 = rectSize / 5f;
-					mpb.setUVRange(u1, v1, u2, v2);
-				}
-				for (int z = -100; z < GameWorld.WORLD_DEPTH; z += rectSize) {
-					rectCount++;
-					bl.set(x, 0, z);
-					tl.set(x, 0, z + rectSize);
-					tr.set(x + rectSize, 0, z + rectSize);
-					br.set(x + rectSize, 0, z);
-					mpb.rect(bl, tl, tr, br, norm);
+			Texture groundTex = Assets.manager.get("textures/ground1.jpg", Texture.class);
+			Material groundMat = new Material(TextureAttribute.createDiffuse(groundTex));
+			MeshPartBuilder mpb = mb.part("ground", GL20.GL_TRIANGLES, Usage.Position | Usage.Normal | Usage.TextureCoordinates, groundMat);
+			float u1 = 0f;
+			float v1 = 0f;
+			float u2 = groundPieceSize / 5f;
+			float v2 = groundPieceSize / 5f;
+			mpb.setUVRange(u1, v1, u2, v2);
+			bl.set(0, 0, 0);
+			tl.set(0, 0, groundPieceSize);
+			tr.set(groundPieceSize, 0, groundPieceSize);
+			br.set(groundPieceSize, 0, 0);
+			//mpb.rect(bl, tl, tr, br, norm);
+			int divisions = ((int) groundPieceSize) / 4;
+			mpb.patch(bl, tl, tr, br, norm, divisions, divisions);
+			Model groundModel = mb.end();
+			models.add(groundModel);
+			groundPieces.clear();
+			int count = 0;
+			for (int x = 0; x < GameWorld.WORLD_WIDTH; x += groundPieceSize) {
+				for (int z = 0; z < GameWorld.WORLD_DEPTH; z += groundPieceSize) {
+					count++;
+					ModelInstance groundPiece = new ModelInstance(groundModel);
+					groundPiece.transform.setToTranslation(x, 0f, z);
+					groundPieces.add(groundPiece);
 				}
 			}
-			Log.debug("createLevel - created ground, rect count: " + rectCount);
-			Model finalModel = mb.end();
-			ground = new ModelInstance(finalModel);
+			Log.debug("createLevel - created " + count + " groundPieces");
 		}
 
 		// physical representation of the ground
@@ -101,7 +106,7 @@ public static void createLevel() {
 		}
 
 		Log.debug("createLevel - create boxes");
-		Box.createBoxes(20, 1, 10, 1, 10);
+		Box.createBoxes(10);
 	}
 
 	/** client builds statics, probably based on info from server */
@@ -163,7 +168,7 @@ private static void createStaticModels() {
 		//float hi = GameWorld.WORLD_WIDTH;
 		float x = 20f;
 		float z = 0f;
-		int numOfStaticObjects = 20;
+		int numOfStaticObjects = 8;
 		for (int i = 0; i < numOfStaticObjects; i++) {
 			x = MathUtils.random(10f, 100f);
 			z = MathUtils.random(10f, 100f);
@@ -197,8 +202,8 @@ private static void createStaticModels() {
 		}
 		if (Main.isClient()) {
 			Model model = mb.end();
-			ModelInstance gate = new ModelInstance(model);
-			staticGeometry.add(gate);
+			ModelInstance modelInst = new ModelInstance(model);
+			staticGeometry.add(modelInst);
 		}
 	}
 

core/src/org/jrenner/fps/LevelBuilder.java

@@ -35,16 +35,16 @@ public class Main extends ApplicationAdapter {
 	public AbstractClient client;
 	public static boolean hasClient;
 	public InputMultiplexer inputMulti;
-	public static Application.ApplicationType Platform;
+	public static Application.ApplicationType platform;
 	public static ServerType serverType;
 
 	@Override
 	public void create () {
 		Log.setLevel(Log.DEBUG);
-		Platform = Gdx.app.getType();
+		platform = Gdx.app.getType();
 		// we can pretend to be Android while running on desktop to test mobile features
 		// such as mobile-specific input
-		// Platform = Application.ApplicationType.Android;
+		//platform = Application.ApplicationType.Android;
 		Assets assets = new Assets();
 		assets.loadAll();
 		Log.debug("finished loading assets");
@@ -207,18 +207,18 @@ public static boolean isMobile() {
 	}
 
 	public static boolean isAndroid() {
-		return Platform == Application.ApplicationType.Android;
+		return platform == Application.ApplicationType.Android;
 	}
 
 	public static boolean isIOS() {
-		return Platform == Application.ApplicationType.iOS;
+		return platform == Application.ApplicationType.iOS;
 	}
 
 	public static boolean isDesktop() {
-		return Platform == Application.ApplicationType.Desktop;
+		return platform == Application.ApplicationType.Desktop;
 	}
 
-	public static boolean isHeadless() { return Platform == Application.ApplicationType.HeadlessDesktop; }
+	public static boolean isHeadless() { return platform == Application.ApplicationType.HeadlessDesktop; }
 
 	public static NetClient getNetClient() {
 		return (NetClient) inst.client;

core/src/org/jrenner/fps/Main.java

@@ -233,9 +233,37 @@ public void debugDrawDynamicEntity(DynamicEntity ent) {
 	private static Vector3[] rectVectors = new Vector3[]{new Vector3(), new Vector3(), new Vector3(), new Vector3()};
 
 	public static int lastDistanceFromGroundRayHitCount;
+	/** if a four-corners raycast was used, more than one ray might have hit, and the avg dist is stored here
+	 * otherwise it is equal to the dist of the single ray hit */
 	public static float lastDistanceFromGroundAvgDist;
 
-	/** finds the distance from the bottom of the passed dimensions to the ground
+	/** finds the distance from the bottom of the of the passed dimensions to the ground
+	 * This method only uses the center point
+	 * This is simpler than checking for each of the four corners
+	 * but less accurate
+	 * @return distance to the ground, or Float.NaN when raycast did not hit the ground */
+	public float distanceFromGroundFast(Vector3 position, Vector3 dimen) {
+		float hitDist = Float.NaN;
+		float downStep = 2f + dimen.y; // length of ray
+		float rayOriginHeight = 0f;
+		// test single point
+		rectVectors[0].set(position);
+		Vector3 point = rectVectors[0];
+		castRayStaticOnly(point, tmp.set(point).sub(0f, downStep, 0f));
+		if (raycastReport.hit) {
+			hitDist = raycastReport.hitDistance;
+		}
+		if (!Float.isNaN(hitDist)) {
+			// if embedded in ground, a negative value will be returned
+			hitDist -= (rayOriginHeight + dimen.y/2f);
+		}
+		lastDistanceFromGroundAvgDist = hitDist;
+		return hitDist;
+	}
+
+	/** finds the distance from the bottom of the passed dimensions to the ground.
+	 * This method uses the four corners of the dimensions
+	 * this is more expensive than checking a single point, but also more accurate
 	 * @return distance to the ground, or Float.NaN when raycast did not hit ground */
 	public float distanceFromGround(Vector3 position, Vector3 dimen) {
 		lastDistanceFromGroundRayHitCount = 0;
@@ -246,7 +274,7 @@ public float distanceFromGround(Vector3 position, Vector3 dimen) {
 		float x = dimen.x / 4f;
 		float z = dimen.z / 4f;
 		float rayOriginHeight = 0f;
-		// by starting the ray from the top of the dimensions
+		// by starting the ray from the center of the dimensions
 		// we can catch cases where the dimensions are already partially
 		// embedded underneath the ground.
 		// in this case, a negative distance will be returned
@@ -265,7 +293,7 @@ public float distanceFromGround(Vector3 position, Vector3 dimen) {
 				}
 			}
 		}
-		// we started the ray from the top, but we want the distance to ground from the bottom
+		// we started the ray from the center, but we want the distance to ground from the bottom
 		if (!Float.isNaN(lowest)) {
 			// if embedded in ground, a negative value will be returned
 			lowest -= (rayOriginHeight + dimen.y/2f);

core/src/org/jrenner/fps/Physics.java

@@ -19,6 +19,7 @@ public class Shadow {
 	private static Model model;
 	public ModelInstance modelInstance;
 	public static Array<Shadow> list;
+	private float height;
 
 	public static void init() {
 		list = new Array<>();
@@ -54,7 +55,12 @@ public Shadow(float size) {
 	private static Vector3 tmp = new Vector3();
 
 	public void update(Vector3 position) {
-		float height = Physics.inst.getShadowHeightAboveGround(position) - heightOffset;
+		// optimize for Mobile
+		if (Main.isMobile() && Main.frame % 6 != 0) {
+			// don't update height
+		} else {
+			height = Physics.inst.getShadowHeightAboveGround(position) - heightOffset;
+		}
 		tmp.set(position.x, position.y - height, position.z);
 		modelInstance.transform.setToTranslation(tmp);
 		modelInstance.transform.rotate(Vector3.Y, Physics.inst.raycastReport.hitNormal);