X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fui%2Fui.cpp;h=5ff408be5fddc4f615eb2122230603b6b8cc6516;hb=f1f8941a3f682fb589cf3c620fc7e7602cfc0f7f;hp=838b1ee8e94168fd02c163803f123383b559c701;hpb=41fdb55c15e95a93067e6df52108f9357b0def34;p=blank.git

diff --git a/src/ui/ui.cpp b/src/ui/ui.cpp
index 838b1ee..5ff408b 100644
--- a/src/ui/ui.cpp
+++ b/src/ui/ui.cpp
@@ -29,6 +29,7 @@
 #include <map>
 #include <sstream>
 #include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/projection.hpp>
 #include <glm/gtx/rotate_vector.hpp>
 #include <glm/gtx/io.hpp>
 
@@ -43,6 +44,7 @@ PlayerController::PlayerController(World &world, Player &player)
 , aim_world()
 , aim_entity() {
 	player.GetEntity().SetController(*this);
+	player.GetEntity().GetSteering().SetAcceleration(5.0f);
 }
 
 PlayerController::~PlayerController() {
@@ -52,24 +54,14 @@ PlayerController::~PlayerController() {
 }
 
 void PlayerController::SetMovement(const glm::vec3 &m) noexcept {
-	if (dot(m, m) > 1.0f) {
-		move_dir = normalize(m);
+	if (glm::dot(m, m) > 1.0f) {
+		move_dir = glm::normalize(m);
 	} else {
 		move_dir = m;
 	}
 	Invalidate();
 }
 
-glm::vec3 PlayerController::ControlForce(const Entity &e, const EntityState &s) const {
-	if (!iszero(move_dir)) {
-		// scale input by max velocity, apply yaw, and transform to world space
-		return TargetVelocity(glm::vec3(glm::vec4(rotateY(move_dir * e.MaxVelocity(), s.yaw), 0.0f) * transpose(e.Transform())), s, 5.0f);
-	} else {
-		// target velocity of 0 is the same as halt
-		return Halt(s, 5.0f);
-	}
-}
-
 void PlayerController::TurnHead(float dp, float dy) noexcept {
 	player.GetEntity().TurnHead(dp, dy);
 }
@@ -97,10 +89,11 @@ void PlayerController::Invalidate() noexcept {
 void PlayerController::UpdatePlayer() noexcept {
 	if (dirty) {
 		Ray aim = player.Aim();
-		if (!world.Intersection(aim, player.GetEntity().ChunkCoords(), aim_world)) {
+		Entity &entity = player.GetEntity();
+		if (!world.Intersection(aim, entity.ChunkCoords(), aim_world)) {
 			aim_world = WorldCollision();
 		}
-		if (!world.Intersection(aim, player.GetEntity(), aim_entity)) {
+		if (!world.Intersection(aim, entity, aim_entity)) {
 			aim_entity = EntityCollision();
 		}
 		if (aim_world && aim_entity) {
@@ -111,6 +104,20 @@ void PlayerController::UpdatePlayer() noexcept {
 				aim_world = WorldCollision();
 			}
 		}
+		Steering &steering = entity.GetSteering();
+		if (!iszero(move_dir)) {
+			// scale input by max velocity, apply yaw, and transform to world space
+			steering.SetTargetVelocity(glm::vec3(
+				glm::vec4(glm::rotateY(move_dir * entity.MaxVelocity(), entity.Yaw()), 0.0f)
+				* glm::transpose(entity.Transform())
+			));
+			steering.Enable(Steering::TARGET_VELOCITY);
+			steering.Disable(Steering::HALT);
+		} else {
+			// target velocity of 0 is the same as halt
+			steering.Enable(Steering::HALT);
+			steering.Disable(Steering::TARGET_VELOCITY);
+		}
 		dirty = false;
 	}
 }
@@ -176,14 +183,59 @@ void DirectInput::PickBlock() {
 }
 
 void DirectInput::PlaceBlock() {
+	// update block focus
 	UpdatePlayer();
+	// do nothing if not looking at any block
 	if (!BlockFocus()) return;
 
+	// determine block adjacent to the face the player is looking at
 	BlockLookup next_block(BlockFocus().chunk, BlockFocus().BlockPos(), Block::NormalFace(BlockFocus().normal));
+	// abort if it's unavailable
 	if (!next_block) {
 		return;
 	}
-	manip.SetBlock(next_block.GetChunk(), next_block.GetBlockIndex(), Block(InventorySlot() + 1));
+
+	// "can replace" check
+	// this prevents players from replacing solid blocks e.g. by looking through slabs
+	// simple for now, should be expanded to include things like
+	// entities in the way or replacable blocks like water and stuff
+	if (next_block.GetBlock().type != 0) {
+		return;
+	}
+
+	Block new_block(InventorySlot() + 1);
+
+	// block's up vector
+	// align with player's up
+	const glm::vec3 player_up(GetPlayer().GetEntity().Up());
+	new_block.SetFace(Block::NormalFace(player_up));
+	// to align with player's local up/down look (like stairs in minecraft), just invert
+	// it if pitch is positive
+	// or, align with focus normal (like logs in minecraft)
+
+	// determine block's turn (local rotation about up axis)
+	// when aligned with player's up (first mode, and currently the only one implemented)
+	// project the player's view forward onto his entity's XZ plane and
+	// use the closest cardinal direction it's pointing in
+	const glm::vec3 view_forward(-GetPlayer().GetEntity().ViewTransform(GetPlayer().GetEntity().ChunkCoords())[2]);
+	// if view is straight up or down, this will be a null vector (NaN after normalization)
+	// in that case maybe the model forward should be used?
+	// the current implementation implicitly falls back to TURN_NONE which is -Z
+	const glm::vec3 local_forward(glm::normalize(view_forward - glm::proj(view_forward, player_up)));
+	// FIXME: I suspect this only works when player_up is positive Y
+	if (local_forward.x > 0.707f) {
+		new_block.SetTurn(Block::TURN_RIGHT);
+	} else if (local_forward.z > 0.707f) {
+		new_block.SetTurn(Block::TURN_AROUND);
+	} else if (local_forward.x < -0.707f) {
+		new_block.SetTurn(Block::TURN_LEFT);
+	}
+	// for mode two ("minecraft stairs") it should work the same, but I haven't properly
+	// thought that through (well, that's also true about the whole face/turn thing, but oh well)
+	// mode three I have absoloutely no clue. that placement would be appropriate for pipe-like
+	// blocks, where turn shouldn't make a difference, but what if it does?
+
+	manip.SetBlock(next_block.GetChunk(), next_block.GetBlockIndex(), new_block);
 	Invalidate();
 }
 
@@ -289,7 +341,7 @@ HUD::HUD(Environment &env, Config &config, const Player &player)
 	buf.indices = std::vector<PrimitiveMesh::Index>({
 		0, 1, 2, 3
 	});
-	buf.colors.resize(4, { 10.0f, 10.0f, 10.0f, 1.0f });
+	buf.colors.resize(4, { 255, 255, 255, 255 });
 	crosshair.Update(buf);
 }