Getting latest

.gitignore

@@ -37,6 +37,7 @@ sysinfo.txt
 
 *.blend1
 *.blend1.meta
-Assets/PostProcessing/
 
-Assets/PostProcessing\.meta
+Logs/
+
+Screenshots/

Assets/Code/AreaSelector.cs

@@ -4,39 +4,42 @@
 using UnityEditor;
 
 public class AreaSelector : MonoBehaviour {
-	public MapGenerator MapGenerator;
+	public MapBehaviour MapBehaviour;
 
-	public Vector3i StartPosition {
+	public Vector3Int StartPosition {
 		get {
-			var start = new Vector3i((this.transform.position) / MapGenerator.BlockSize);
-			if (start.Y >= this.MapGenerator.Height) {
-				start.Y = this.MapGenerator.Height - 1;
+			var start = Vector3Int.RoundToInt((this.transform.position) / InfiniteMap.BLOCK_SIZE);
+			if (start.y >= this.MapBehaviour.Map.Height) {
+				start.y = this.MapBehaviour.Map.Height - 1;
 			}
-			if (start.Y < 0) {
-				start.Y = 0;
+			if (start.y < 0) {
+				start.y = 0;
 			}
 			return start;
 		}
 	}
 
-	public Vector3i Size {
+	public Vector3Int Size {
 		get {
 			var start = this.StartPosition;
-			var size = new Vector3i(this.transform.localScale / MapGenerator.BlockSize);
-			if (size.Y + start.Y >= this.MapGenerator.Height) {
-				size.Y = System.Math.Max(0, this.MapGenerator.Height - start.Y);
+			var size = Vector3Int.RoundToInt(this.transform.localScale / InfiniteMap.BLOCK_SIZE);
+			if (size.y + start.y >= this.MapBehaviour.Map.Height) {
+				size.y = System.Math.Max(0, this.MapBehaviour.Map.Height - start.y);
 			}
 			return size;
 		}
 	}
 
 #if UNITY_EDITOR
-	[DrawGizmo(GizmoType.InSelectionHierarchy | GizmoType.NotInSelectionHierarchy)]
+	[DrawGizmo(GizmoType.Selected)]
 	static void DrawGizmoForMyScript(AreaSelector areaSelector, GizmoType gizmoType) {
-		var size = areaSelector.Size.ToVector3() * MapGenerator.BlockSize;
-		var start = areaSelector.StartPosition.ToVector3() * MapGenerator.BlockSize - new Vector3(1f, 0, 1f) * MapGenerator.BlockSize * 0.5f;
+		if (areaSelector.MapBehaviour == null || !areaSelector.MapBehaviour.Initialized) {
+			return;
+		}
+		var size = areaSelector.Size.ToVector3() * InfiniteMap.BLOCK_SIZE;
+		var start = areaSelector.StartPosition.ToVector3() * InfiniteMap.BLOCK_SIZE - new Vector3(1f, 0, 1f) * InfiniteMap.BLOCK_SIZE * 0.5f;
 		Gizmos.color = Color.red;
-		Gizmos.DrawWireCube(areaSelector.MapGenerator.transform.position + start + size * 0.5f, size);
+		Gizmos.DrawWireCube(areaSelector.MapBehaviour.transform.position + start + size * 0.5f, size);
 	}
 #endif
 }

Assets/Code/CameraControl/ControlModeSwitcher.cs

@@ -0,0 +1,57 @@
+using UnityEngine;
+using System.Linq;
+using System;
+
+public class ControlModeSwitcher : MonoBehaviour {
+	[System.Serializable]
+	public class ControlMode {
+		public KeyCode KeyCode;
+		public MonoBehaviour Behaviour;
+	}
+
+	public ControlMode[] ControlModes;
+
+	public KeyCode[] ModeSwitchKeys;
+
+	private ControlMode currentMode;
+
+	void Start() {
+		Cursor.visible = false;
+		Cursor.lockState = CursorLockMode.Locked;
+		if (this.ControlModes.Any()) {
+			this.SetMode(this.ControlModes[0]);
+		}
+		foreach (var mode in this.ControlModes) {
+			if (mode != this.currentMode) {
+				mode.Behaviour.enabled = false;
+			}
+		}
+	}
+
+	void Update() {
+		foreach (var mode in this.ControlModes) {
+			if (Input.GetKeyDown(mode.KeyCode)) {
+				this.SetMode(mode);
+			}
+		}
+		if (this.currentMode != null && this.ModeSwitchKeys != null) {
+			foreach (var keyCode in this.ModeSwitchKeys) {
+				if (Input.GetKeyDown(keyCode)) {
+					int currentIndex = Array.IndexOf(this.ControlModes, this.currentMode);
+					this.SetMode(this.ControlModes[(currentIndex + 1) % this.ControlModes.Length]);
+				}
+			}
+		}
+	}
+
+	void SetMode(ControlMode mode) {
+		if (this.currentMode == mode) {
+			return;
+		}
+		if (this.currentMode != null) {
+			this.currentMode.Behaviour.enabled = false;
+		}
+		this.currentMode = mode;
+		this.currentMode.Behaviour.enabled = true;
+	}
+}

Assets/Code/FirstPersonController.cs → Assets/Code/CameraControl/FirstPersonController.cs

@@ -8,8 +8,11 @@ public class FirstPersonController : MonoBehaviour {
 	[Range(1f, 5f)]
 	public float MovementSpeed = 1f;
 
-	[Range(1, 200f)]
-	public float LookSensitivity = 10f;
+	[Range(1, 500f)]
+	public float LookSensitivity = 200f;
+
+	[Range(1, 500f)]
+	public float MouseSensitivity = 3;
 
 	[Range(1, 100f)]
 	public float JumpStrength = 2f;
@@ -22,23 +25,29 @@ public class FirstPersonController : MonoBehaviour {
 	private float timeInAir = 0f;
 	private bool jumpLocked = false;
 
-	void Start () {
+	public LayerMask CollisionLayers;
+
+	void OnEnable() {
 		this.characterController = this.GetComponent<CharacterController>();
 		this.cameraTransform = this.GetComponentInChildren<Camera>().transform;
-		Cursor.visible = false;
+		this.cameraTilt = this.cameraTransform.localRotation.eulerAngles.x;
 	}
 
 	void Update () {
 		bool touchesGround = this.onGround();
 		float runMultiplier = 1f + 2f * Input.GetAxis("Run");
 		float y = this.transform.position.y;
-		this.characterController.Move(this.transform.forward * Input.GetAxis("Move Y") * Time.deltaTime * this.MovementSpeed * runMultiplier + this.transform.right * Input.GetAxis("Move X") * Time.deltaTime * this.MovementSpeed * runMultiplier);
+		Vector3 movementVector = this.transform.forward * Input.GetAxis("Move Y") + this.transform.right * Input.GetAxis("Move X");
+		if (movementVector.sqrMagnitude > 1) {
+			movementVector.Normalize();  // this prevents diagonal movement form being too fast
+		}
+		this.characterController.Move(movementVector * Time.deltaTime * this.MovementSpeed * runMultiplier);
 		float verticalMovement = this.transform.position.y - y;
 		if (verticalMovement < 0) {
 			this.transform.position += Vector3.down * verticalMovement;
 		}
-		this.transform.rotation = Quaternion.AngleAxis(Input.GetAxis("Look X") * Time.deltaTime * this.LookSensitivity, Vector3.up) * this.transform.rotation;
-		this.cameraTilt = Mathf.Clamp(this.cameraTilt - Input.GetAxis("Look Y") * this.LookSensitivity * Time.deltaTime, -90f, 90f);
+		this.transform.localRotation = Quaternion.AngleAxis(Input.GetAxis("Mouse Look X") * this.MouseSensitivity + Input.GetAxis("Look X") * this.LookSensitivity * Time.deltaTime, Vector3.up) * this.transform.rotation;
+		this.cameraTilt = Mathf.Clamp(this.cameraTilt - Input.GetAxis("Mouse Look Y") * this.MouseSensitivity - Input.GetAxis("Look Y") * this.LookSensitivity * Time.deltaTime, -90f, 90f);
 		this.cameraTransform.localRotation = Quaternion.AngleAxis(this.cameraTilt, Vector3.right);
 
 		if (touchesGround) {
@@ -64,18 +73,14 @@ void Update () {
 			this.verticalSpeed = 2f;
 		}
 		this.characterController.Move(Vector3.up * Time.deltaTime * this.verticalSpeed);
+	}
 
-		if (Input.GetKeyDown(FlightController.OnOffKey)) {
-			var flyBehaviour = this.GetComponent<FlightController>();
-			if (flyBehaviour != null) {
-				this.GetComponent<FlightController>().enabled = true;
-			}
-			this.cameraTilt = 24;
-		}
+	public void Enable() {
+		this.verticalSpeed = 0;
 	}
 
 	private bool onGround() {
 		var ray = new Ray(this.transform.position, Vector3.down);
-		return Physics.SphereCast(ray, this.characterController.radius, this.characterController.height / 2 - this.characterController.radius + 0.1f);
+		return Physics.SphereCast(ray, this.characterController.radius, this.characterController.height / 2 - this.characterController.radius + 0.1f, this.CollisionLayers);
 	}
 }

Assets/Code/FlightController.cs → Assets/Code/CameraControl/FlightController.cs

@@ -3,15 +3,13 @@
 using UnityEngine;
 
 public class FlightController : MonoBehaviour {
+	public float Velocity = 3;
 
-	[Range(0f, 20f)]
-	public float Velocity;
-
-	public const KeyCode OnOffKey = KeyCode.M;
+	[Range(1, 500f)]
+	public float LookSensitivity = 200f;
 
 	public void OnEnable() {
-		this.GetComponent<FirstPersonController>().enabled = false;
-		this.transform.position = this.transform.position - Vector3.up * this.transform.position.y + Vector3.up * (GameObject.FindObjectOfType<MapGenerator>().Height * MapGenerator.BlockSize + 2f);
+		this.transform.position = this.transform.position - Vector3.up * this.transform.position.y + Vector3.up * (GameObject.FindObjectOfType<MapBehaviour>().Map.Height * InfiniteMap.BLOCK_SIZE + 2f);
 		var cameraTransform = this.transform.GetChild(0);
 		cameraTransform.rotation = Quaternion.Euler(cameraTransform.rotation.eulerAngles - Vector3.right * cameraTransform.rotation.eulerAngles.x + Vector3.right * 24f);
 	}
@@ -20,11 +18,7 @@ void Update () {
 		var direction = this.transform.forward + Vector3.down * this.transform.forward.y;
 		this.transform.position += direction.normalized * this.Velocity * Time.deltaTime;
 
-		if (Input.GetKeyDown(FlightController.OnOffKey)) {
-			this.enabled = false;
-			this.GetComponent<FirstPersonController>().enabled = true;
-		}
-
-		this.Velocity = Mathf.Clamp(this.Velocity + Input.GetAxis("Move Y") * Time.deltaTime * 2f, 0f, 20f);
+		this.Velocity = Mathf.Clamp(this.Velocity + Input.GetAxis("Move Y") * Time.deltaTime * 4f, 0f, 20f);
+		this.transform.rotation = Quaternion.Euler(Vector3.up * (Input.GetAxis("Look X") + Input.GetAxis("Mouse Look X")) * Time.deltaTime * this.LookSensitivity) * this.transform.rotation;
 	}
 }

Assets/Code/CameraControl/FreeCameraController.cs

@@ -0,0 +1,44 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class FreeCameraController : MonoBehaviour
+{
+	[Range(1f, 10f)]
+	public float MovementSpeed = 2f;
+
+	[Range(1, 500f)]
+	public float LookSensitivity = 200f;
+
+	[Range(1, 500f)]
+	public float MouseSensitivity = 3;
+
+	private CharacterController characterController;
+	private Transform cameraTransform;
+
+	private float cameraTilt = 0f;
+
+	void OnEnable() {
+		this.characterController = this.GetComponent<CharacterController>();
+		this.cameraTransform = this.GetComponentInChildren<Camera>().transform;
+		this.cameraTilt = this.cameraTransform.localRotation.eulerAngles.x;
+	}
+
+	void Update() {
+		Vector3 movementVector = this.cameraTransform.forward * Input.GetAxis("Move Y")
+			+ this.cameraTransform.right * Input.GetAxis("Move X")
+			+ Vector3.up * (Input.GetAxis("Move Up/Down") + Input.GetAxisRaw("Jump"));
+
+		if (movementVector.sqrMagnitude > 1) {
+			movementVector.Normalize();
+		}
+		if (Input.GetAxisRaw("Run") > 0.1f) {
+			movementVector *= 4;
+		}
+		this.characterController.Move(movementVector * Time.deltaTime * this.MovementSpeed);
+
+		this.transform.localRotation = Quaternion.AngleAxis(Input.GetAxis("Mouse Look X") * this.MouseSensitivity + Input.GetAxis("Look X") * this.LookSensitivity * Time.deltaTime, Vector3.up) * this.transform.rotation;
+		this.cameraTilt = Mathf.Clamp(this.cameraTilt - Input.GetAxis("Mouse Look Y") * this.MouseSensitivity - Input.GetAxis("Look Y") * this.LookSensitivity * Time.deltaTime, -90f, 90f);
+		this.cameraTransform.localRotation = Quaternion.AngleAxis(this.cameraTilt, Vector3.right);
+	}
+}

Assets/Code/Culling/Chunk.cs

@@ -0,0 +1,84 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Chunk {
+	public readonly Bounds Bounds;
+
+	public List<Renderer> Renderers;
+	public List<GameObject> GameObjects;
+	public List<Portal> Portals;
+	public List<Room> Rooms;
+
+	private Dictionary<Vector3Int, Renderer[]> renderersByPosition;
+
+	public bool ExteriorBlocksVisible = true;
+	public bool InRenderRange {
+		get;
+		private set;
+	}
+
+	public Chunk(Bounds bounds) {
+		this.Bounds = bounds;
+		this.Renderers = new List<Renderer>();
+		this.Portals = new List<Portal>();
+		this.Rooms = new List<Room>();
+		this.renderersByPosition = new Dictionary<Vector3Int, Renderer[]>();
+		this.GameObjects = new List<GameObject>();
+		this.InRenderRange = true;
+	}
+
+	public void SetInRenderRange(bool value) {
+		this.InRenderRange = value;
+		foreach (var gameObject in this.GameObjects) {
+			gameObject.SetActive(value);
+		}
+		// This only works for small rooms.
+		// It will fail if a room has blocks outside the render range and close to the player. 
+		foreach (var room in this.Rooms) {
+			foreach (var slot in room.Slots) {
+				slot.GameObject.SetActive(value);
+			}
+		}
+	}
+
+	public void SetExteriorVisibility(bool value) {
+		if (this.ExteriorBlocksVisible == value) {
+			return;
+		}
+		foreach (var renderer in this.Renderers) {
+			renderer.shadowCastingMode = value ? UnityEngine.Rendering.ShadowCastingMode.On : UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly;
+		}
+		this.ExteriorBlocksVisible = value;
+	}
+
+	public void SetRoomVisibility(bool value) {
+		foreach (var room in this.Rooms) {
+			room.SetVisibility(value);
+		}
+	}
+
+	public void AddBlock(Slot slot) {
+		if (this.renderersByPosition.ContainsKey(slot.Position)) {
+			foreach (var renderer in this.renderersByPosition[slot.Position]) {
+				this.Renderers.Remove(renderer);
+			}
+		}
+		var renderers = slot.GameObject.GetComponentsInChildren<Renderer>();
+		this.renderersByPosition[slot.Position] = renderers;
+		this.Renderers.AddRange(renderers);
+		this.ExteriorBlocksVisible = true;
+		this.GameObjects.Add(slot.GameObject);
+		slot.GameObject.SetActive(this.InRenderRange);
+	}
+
+	public void RemoveBlock(Slot slot) {
+		if (!this.renderersByPosition.ContainsKey(slot.Position)) {
+			return;
+		}
+		foreach (var renderer in this.renderersByPosition[slot.Position]) {
+			this.Renderers.Remove(renderer);
+		}
+		this.GameObjects.Remove(slot.GameObject);
+	}
+}