Added collisions with world

src/main/java/ru/windcorp/progressia/client/graphics/world/LayerWorld.java

@@ -124,7 +124,7 @@ public class LayerWorld extends Layer {
 	private final Collider.ColliderWorkspace tmp_colliderWorkspace = new Collider.ColliderWorkspace();
 	private final List<Collideable> tmp_collideableList = new ArrayList<>();
 	
-	private static final boolean RENDER_COLLISION_MODELS = true;
+	private static final boolean RENDER_COLLISION_MODELS = false;
 	
 	private void tmp_doEveryFrame() {
 		try {
@@ -136,7 +136,7 @@ public class LayerWorld extends Layer {
 			}
 		} catch (Throwable e) {
 			e.printStackTrace();
-			System.out.println("OLEGSHA is to blame. Tell him he vry stupiDD!!");
+			System.err.println("OLEGSHA is to blame. Tell him he vry stupiDD!!");
 			System.exit(31337);
 		}
 	}

src/main/java/ru/windcorp/progressia/common/collision/AABB.java

@@ -42,6 +42,8 @@ public class AABB implements AABBoid {
 		
 	}
 	
+	public static final AABB UNIT_CUBE = new AABB(0, 0, 0, 1, 1, 1);
+	
 	private final Wall[] walls = new Wall[] {
 			new AABBWallImpl(-0.5f, -0.5f, +0.5f,   +1,  0,  0,    0, +1,  0), // Top
 			new AABBWallImpl(-0.5f, -0.5f, -0.5f,    0, +1,  0,   +1,  0,  0), // Bottom

src/main/java/ru/windcorp/progressia/common/collision/CollisionPathComputer.java

@@ -0,0 +1,79 @@
+package ru.windcorp.progressia.common.collision;
+
+import java.util.function.Consumer;
+
+import glm.vec._3.Vec3;
+import glm.vec._3.i.Vec3i;
+import ru.windcorp.progressia.common.util.Vectors;
+
+import static java.lang.Math.*;
+
+public class CollisionPathComputer {
+	
+	public static void forEveryBlockInCollisionPath(
+			Collideable coll,
+			float maxTime,
+			Consumer<Vec3i> action
+	) {
+		Vec3 displacement = Vectors.grab3();
+		coll.getCollideableVelocity(displacement);
+		displacement.mul(maxTime);
+		
+		handleModel(coll.getCollisionModel(), displacement, action);
+		
+		Vectors.release(displacement);
+	}
+
+	private static void handleModel(
+			CollisionModel model,
+			Vec3 displacement,
+			Consumer<Vec3i> action
+	) {
+		if (model instanceof CompoundCollisionModel) {
+			for (CollisionModel subModel : ((CompoundCollisionModel) model).getModels()) {
+				handleModel(subModel, displacement, action);
+			}
+		} else if (model instanceof AABBoid) {
+			handleAABBoid((AABBoid) model, displacement, action);
+		} else {
+			throw new RuntimeException("not supported");
+		}
+	}
+
+	private static void handleAABBoid(AABBoid model, Vec3 displacement, Consumer<Vec3i> action) {
+		Vec3 size = Vectors.grab3();
+		Vec3 origin = Vectors.grab3();
+		
+		model.getOrigin(origin);
+		model.getSize(size);
+		
+		origin.mul(2).sub(size).div(2); // Subtract 0.5*size
+		
+		Vec3i pos = Vectors.grab3i();
+		
+		for (
+				pos.x =  (int) floor(origin.x + min(0, size.x) + min(0, displacement.x));
+				pos.x <= (int)  ceil(origin.x + max(0, size.x) + max(0, displacement.x));
+				pos.x += 1
+		) {
+			for (
+					pos.y =  (int) floor(origin.y + min(0, size.y) + min(0, displacement.y));
+					pos.y <= (int)  ceil(origin.y + max(0, size.y) + max(0, displacement.y));
+					pos.y += 1
+			) {
+				for (
+						pos.z =  (int) floor(origin.z + min(0, size.z) + min(0, displacement.z));
+						pos.z <= (int)  ceil(origin.z + max(0, size.z) + max(0, displacement.z));
+						pos.z += 1
+				) {
+					action.accept(pos);
+				}
+			}
+		}
+		
+		Vectors.release(origin);
+		Vectors.release(size);
+		Vectors.release(pos);
+	}
+
+}

src/main/java/ru/windcorp/progressia/common/collision/CompoundCollisionModel.java

@@ -8,9 +8,9 @@ import glm.vec._3.Vec3;
 
 public class CompoundCollisionModel implements CollisionModel {
 	
-	private final Collection<CollisionModel> models;
+	private final Collection<? extends CollisionModel> models;
 
-	public CompoundCollisionModel(Collection<CollisionModel> models) {
+	public CompoundCollisionModel(Collection<? extends CollisionModel> models) {
 		this.models = models;
 	}
 	
@@ -18,7 +18,7 @@ public class CompoundCollisionModel implements CollisionModel {
 		this(ImmutableList.copyOf(models));
 	}
 	
-	public Collection<CollisionModel> getModels() {
+	public Collection<? extends CollisionModel> getModels() {
 		return models;
 	}
 

src/main/java/ru/windcorp/progressia/common/collision/WorldCollisionHelper.java

@@ -0,0 +1,94 @@
+package ru.windcorp.progressia.common.collision;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import glm.vec._3.Vec3;
+import glm.vec._3.i.Vec3i;
+import ru.windcorp.progressia.common.util.LowOverheadCache;
+import ru.windcorp.progressia.common.world.WorldData;
+
+public class WorldCollisionHelper {
+	
+	private final Collideable collideable = new Collideable() {
+		@Override
+		public boolean onCollision(Collideable other) {
+			return false;
+		}
+		
+		@Override
+		public void moveAsCollideable(Vec3 displacement) {
+			// Ignore
+			assert displacement.length() < 1e-3f;
+		}
+		
+		@Override
+		public CollisionModel getCollisionModel() {
+			return WorldCollisionHelper.this.model;
+		}
+		
+		@Override
+		public float getCollisionMass() {
+			return Float.POSITIVE_INFINITY;
+		}
+		
+		@Override
+		public void getCollideableVelocity(Vec3 output) {
+			output.set(0);
+		}
+		
+		@Override
+		public void changeVelocityOnCollision(Vec3 velocityChange) {
+			// Ignore
+			assert velocityChange.length() < 1e-3f;
+		}
+	};
+	
+	private final Collection<TranslatedAABB> activeBlockModels = new ArrayList<>();
+	private final CollisionModel model = new CompoundCollisionModel(activeBlockModels);
+	private final LowOverheadCache<TranslatedAABB> blockModelCache = new LowOverheadCache<>(TranslatedAABB::new);
+	
+	/**
+	 * Changes the state of this helper's {@link #getCollideable()} so it is ready to adequately handle
+	 * collisions with the {@code collideable} that might happen in the next {@code maxTime} seconds.
+	 * This helper is only valid for checking collisions with the given Collideable and only within
+	 * the given time limit.
+	 * @param collideable the {@link Collideable} that collisions will be checked against
+	 * @param maxTime maximum collision time
+	 */
+	public void tuneToCollideable(WorldData world, Collideable collideable, float maxTime) {
+		activeBlockModels.forEach(blockModelCache::release);
+		activeBlockModels.clear();
+		CollisionPathComputer.forEveryBlockInCollisionPath(
+				collideable,
+				maxTime,
+				v -> addModel(world.getCollisionModelOfBlock(v), v)
+		);
+	}
+	
+	private void addModel(CollisionModel model, Vec3i pos) {
+		if (model == null) {
+			// Ignore
+		} else if (model instanceof AABBoid) {
+			addAABBoidModel((AABBoid) model, pos);
+		} else if (model instanceof CompoundCollisionModel) {
+			for (CollisionModel subModel : ((CompoundCollisionModel) model).getModels()) {
+				addModel(subModel, pos);
+			}
+		} else {
+			throw new RuntimeException("not supported");
+		}
+	}
+	
+	private void addAABBoidModel(AABBoid model, Vec3i pos) {
+		TranslatedAABB translator = blockModelCache.grab();
+		translator.setParent(model);
+		translator.setTranslation(pos.x, pos.y, pos.z);
+		activeBlockModels.add(translator);
+	}
+
+	public Collideable getCollideable() {
+		return collideable;
+	}
+
+}

src/main/java/ru/windcorp/progressia/common/collision/colliders/Collider.java

@@ -33,7 +33,7 @@ public class Collider {
 				return;
 			}
 			
-			Collision firstCollision = getFirstCollision(colls, tickLength, workspace);
+			Collision firstCollision = getFirstCollision(colls, tickLength, world, workspace);
 			
 			if (firstCollision == null) {
 				break;
@@ -52,39 +52,43 @@ public class Collider {
 	private static Collision getFirstCollision(
 			List<? extends Collideable> colls,
 			float tickLength,
+			WorldData world,
 			ColliderWorkspace workspace
 	) {
 		Collision result = null;
+		Collideable worldColl = workspace.worldCollisionHelper.getCollideable();
 		
 		// For every pair of colls
 		for (int i = 0; i < colls.size(); ++i) {
 			Collideable a = colls.get(i);
 			
+			tuneWorldCollisionHelper(a, tickLength, world, workspace);
+			
+			result = workspace.updateLatestCollision(
+					result,
+					getCollision(a, worldColl, tickLength, workspace)
+			);
+			
 			for (int j = i + 1; j < colls.size(); ++j) {
 				Collideable b = colls.get(j);
-				
 				Collision collision = getCollision(a, b, tickLength, workspace);
-				
-				// Update result
-				if (collision != null) {
-					Collision second;
-					
-					if (result == null || collision.time < result.time) {
-						second = result;
-						result = collision;
-					} else {
-						second = collision;
-					}
-					
-					// Release Collision that is no longer used
-					if (second != null) workspace.release(second);
-				}
+				result = workspace.updateLatestCollision(result, collision);
 			}
 		}
 		
 		return result;
 	}
 	
+	private static void tuneWorldCollisionHelper(
+			Collideable coll,
+			float tickLength,
+			WorldData world,
+			ColliderWorkspace workspace
+	) {
+		WorldCollisionHelper wch = workspace.worldCollisionHelper;
+		wch.tuneToCollideable(world, coll, tickLength);
+	}
+
 	static Collision getCollision(
 			Collideable a,
 			Collideable b,
@@ -104,7 +108,7 @@ public class Collider {
 			float tickLength,
 			ColliderWorkspace workspace
 	) {
-		if (aModel instanceof AABBoid && bModel instanceof AABBoid) { /*replace AABB with AABBoid where makes sense, also add TranslatedAABB support in TestAABBRenderer*/
+		if (aModel instanceof AABBoid && bModel instanceof AABBoid) {
 			return AABBoidCollider.computeModelCollision(
 					aBody, bBody,
 					(AABBoid) aModel, (AABBoid) bModel,
@@ -324,6 +328,8 @@ public class Collider {
 				new LowOverheadCache<>(Collision::new);
 		
 		AABB dummyAABB = new AABB(0, 0, 0, 1, 1, 1);
+		
+		WorldCollisionHelper worldCollisionHelper = new WorldCollisionHelper();
 
 		Collision grab() {
 			return collisionCache.grab();
@@ -333,6 +339,27 @@ public class Collider {
 			collisionCache.release(object);
 		}
 		
+		Collision updateLatestCollision(Collision a, Collision b) {
+			if (a == null) {
+				return b; // may be null
+			} else if (b == null) {
+				return a;
+			}
+			
+			Collision first, second;
+			
+			if (a.time > b.time) {
+				first = b;
+				second = a;
+			} else {
+				first = a;
+				second = b;
+			}
+			
+			release(second);
+			return first;
+		}
+		
 	}
 	
 	static class Collision {

src/main/java/ru/windcorp/progressia/common/world/WorldData.java

@@ -24,8 +24,10 @@ import glm.vec._3.i.Vec3i;
 import gnu.trove.impl.sync.TSynchronizedLongObjectMap;
 import gnu.trove.map.TLongObjectMap;
 import gnu.trove.map.hash.TLongObjectHashMap;
+import ru.windcorp.progressia.common.collision.CollisionModel;
 import ru.windcorp.progressia.common.util.CoordinatePacker;
 import ru.windcorp.progressia.common.util.Vectors;
+import ru.windcorp.progressia.common.world.block.BlockData;
 import ru.windcorp.progressia.common.world.entity.EntityData;
 
 public class WorldData {
@@ -106,8 +108,17 @@ public class WorldData {
 		this.time += change;
 	}
 	
-//	public CollisionModel getCollisionModelOfBlock(Vec3i blockInWorld) {
-//		Vec3i 
-//	}
+	public CollisionModel getCollisionModelOfBlock(Vec3i blockInWorld) {
+		ChunkData chunk = getChunkByBlock(blockInWorld);
+		if (chunk == null) return null;
+		
+		Vec3i blockInChunk = Vectors.grab3i();
+		Coordinates.convertInWorldToInChunk(blockInWorld, blockInChunk);
+		BlockData block = chunk.getBlock(blockInChunk);
+		Vectors.release(blockInChunk);
+		
+		if (block == null) return null;
+		return block.getCollisionModel();
+	}
 	
 }

src/main/java/ru/windcorp/progressia/common/world/block/BlockData.java

@@ -17,6 +17,8 @@
  *******************************************************************************/
 package ru.windcorp.progressia.common.world.block;
 
+import ru.windcorp.progressia.common.collision.AABB;
+import ru.windcorp.progressia.common.collision.CollisionModel;
 import ru.windcorp.progressia.common.util.Namespaced;
 
 public class BlockData extends Namespaced {
@@ -24,5 +26,9 @@ public class BlockData extends Namespaced {
 	public BlockData(String namespace, String name) {
 		super(namespace, name);
 	}
+	
+	public CollisionModel getCollisionModel() {
+		return AABB.UNIT_CUBE;
+	}
 
 }

src/main/java/ru/windcorp/progressia/test/TestContent.java

@@ -14,6 +14,7 @@ import ru.windcorp.progressia.client.world.block.*;
 import ru.windcorp.progressia.client.world.entity.*;
 import ru.windcorp.progressia.client.world.tile.*;
 import ru.windcorp.progressia.common.collision.AABB;
+import ru.windcorp.progressia.common.collision.CollisionModel;
 import ru.windcorp.progressia.common.comms.controls.*;
 import ru.windcorp.progressia.common.state.StatefulObjectRegistry.Factory;
 import ru.windcorp.progressia.common.world.ChunkData;
@@ -41,7 +42,12 @@ public class TestContent {
 	}
 
 	private static void registerBlocks() {
-		register(new BlockData("Test", "Air"));
+		register(new BlockData("Test", "Air") {
+				@Override
+				public CollisionModel getCollisionModel() {
+					return null;
+				}
+		});
 		register(new BlockRenderNone("Test", "Air"));
 		register(new BlockLogic("Test", "Air"));
 

src/main/java/ru/windcorp/progressia/test/TestEntityDataStatie.java

@@ -1,8 +1,6 @@
 package ru.windcorp.progressia.test;
 
 import ru.windcorp.progressia.common.collision.AABB;
-import ru.windcorp.progressia.common.collision.CompoundCollisionModel;
-import ru.windcorp.progressia.common.collision.TranslatedAABB;
 import ru.windcorp.progressia.common.state.IntStateField;
 import ru.windcorp.progressia.common.world.entity.EntityData;
 
@@ -13,10 +11,7 @@ public class TestEntityDataStatie extends EntityData {
 
 	public TestEntityDataStatie() {
 		super("Test", "Statie");
-		setCollisionModel(new CompoundCollisionModel(
-				new AABB(0, 0, 0,    1,    1,    1   ),
-				new TranslatedAABB(new AABB(0, 0, 0.7f, 0.6f, 0.6f, 0.6f), 0, 0, 1)
-		));
+		setCollisionModel(new AABB(0, 0, 0, 1, 1, 1));
 		setSizeNow(16);
 	}