feat: working rotations

dGame/dComponents/ModelComponent.cpp

@@ -1,8 +1,13 @@
 #include "ModelComponent.h"
+
+#include <cmath>
+
 #include "Entity.h"
 
 #include "Game.h"
 #include "Logger.h"
+#include "dConfig.h"
+#include "dMath.h"
 
 #include "BehaviorStates.h"
 #include "ControlBehaviorMsgs.h"
@@ -19,7 +24,6 @@
 ModelComponent::ModelComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
 	m_OriginalPosition = m_Parent->GetDefaultPosition();
 	m_OriginalRotation = m_Parent->GetDefaultRotation();
-	LOG("%f %f %f %f", m_OriginalRotation.x, m_OriginalRotation.y, m_OriginalRotation.z, m_OriginalRotation.w);
 	m_IsPaused = false;
 	m_NumListeningInteract = 0;
 
@@ -43,10 +47,7 @@ bool ModelComponent::OnResetModelToDefaults(GameMessages::ResetModelToDefaults&
 	if (reset.bResetPos) m_Parent->SetPosition(m_OriginalPosition);
 	if (reset.bResetRot) m_Parent->SetRotation(m_OriginalRotation);
 	m_Parent->SetVelocity(NiPoint3Constant::ZERO);
-	GameMessages::SetAngularVelocity setAngVel;
-	setAngVel.target = m_Parent->GetObjectID();
-	setAngVel.angVelocity = NiPoint3Constant::ZERO;
-	setAngVel.Send();
+	ResetRotationState(m_Parent->GetRotation());
 
 	m_Speed = 3.0f;
 	m_NumListeningInteract = 0;
@@ -317,36 +318,60 @@ void ModelComponent::SetVelocity(const NiPoint3& velocity) const {
 	m_Parent->SetVelocity(velocity);
 }
 
-bool ModelComponent::TrySetAngularVelocity(const NiPoint3& angularVelocity) const {
-	GameMessages::GetAngularVelocity getAngVel{};
-	getAngVel.target = m_Parent->GetObjectID();
-	if (!getAngVel.Send()) {
-		LOG("Couldn't get angular velocity for %llu", m_Parent->GetObjectID());
-		return false;
+bool ModelComponent::TryStartRotation(const int axis, const float direction) {
+	if (axis < 0 || axis > 2 || direction == 0.0f) return false;
+	if (m_RotationDirection[axis] != 0.0f) return false;
+
+	// Rebase only when nothing is rotating so simultaneous rotations stay relative to the same base
+	if (m_RotationDirection == NiPoint3Constant::ZERO) {
+		ResetRotationState(m_Parent->GetRotation());
+		m_SendAngularVelocity = Game::config->GetValue("model_rotation_send_angular_velocity") != "0";
 	}
 
+	m_RotationDegrees[axis] = std::fmod(m_RotationDegrees[axis], 360.0f);
+	m_RotationActionStart[axis] = m_RotationDegrees[axis];
+	m_RotationDirection[axis] = direction > 0.0f ? 1.0f : -1.0f;
+	SyncAngularVelocity();
+	return true;
+}
+
+void ModelComponent::SetRotationProgress(const int axis, const float degrees) {
+	if (axis < 0 || axis > 2) return;
+	m_RotationDegrees[axis] = m_RotationActionStart[axis] + degrees;
+
+	// Whole turns wrap to exactly 0 so e.g. 720 degrees yields exactly the base rotation
+	const NiPoint3 radians(
+		Math::DegToRad(std::fmod(m_RotationDegrees.x, 360.0f)),
+		Math::DegToRad(std::fmod(m_RotationDegrees.y, 360.0f)),
+		Math::DegToRad(std::fmod(m_RotationDegrees.z, 360.0f))
+	);
+	m_Parent->SetRotation(QuatUtils::FromEuler(radians) * m_RotationBase);
+}
+
+void ModelComponent::StopRotation(const int axis) {
+	if (axis < 0 || axis > 2) return;
+	m_RotationDirection[axis] = 0.0f;
+	SyncAngularVelocity();
+}
+
+void ModelComponent::SetSpeed(const float newSpeed) {
+	m_Speed = newSpeed;
+	if (m_RotationDirection != NiPoint3Constant::ZERO) SyncAngularVelocity();
+}
+
+void ModelComponent::SyncAngularVelocity() const {
 	GameMessages::SetAngularVelocity setAngVel{};
 	setAngVel.target = m_Parent->GetObjectID();
-	if (angularVelocity != NiPoint3Constant::ZERO) {
-		setAngVel.angVelocity = getAngVel.angVelocity;
-		const auto [x, y, z] = angularVelocity * m_Speed;
-		if (x != 0.0f) {
-			if (getAngVel.angVelocity.x != 0.0f) return false;
-			setAngVel.angVelocity.x = x;
-		} else if (y != 0.0f) {
-			if (getAngVel.angVelocity.y != 0.0f) return false;
-			setAngVel.angVelocity.y = y;
-		} else if (z != 0.0f) {
-			if (getAngVel.angVelocity.z != 0.0f) return false;
-			setAngVel.angVelocity.z = z;
-		}
-	} else {
-		setAngVel.angVelocity = angularVelocity;
-	}
-	LOG("Setting angular velocity to %f %f %f", setAngVel.angVelocity.x, setAngVel.angVelocity.y, setAngVel.angVelocity.z);
+	setAngVel.angVelocity = m_SendAngularVelocity ? m_RotationDirection * Math::DegToRad(GetAngularSpeed()) : NiPoint3Constant::ZERO;
 	setAngVel.Send();
+}
 
-	return true;
+void ModelComponent::ResetRotationState(const NiQuaternion& newBase) {
+	m_RotationBase = newBase;
+	m_RotationDegrees = NiPoint3Constant::ZERO;
+	m_RotationActionStart = NiPoint3Constant::ZERO;
+	m_RotationDirection = NiPoint3Constant::ZERO;
+	SyncAngularVelocity();
 }
 
 void ModelComponent::OnChatMessageReceived(const std::string& sMessage) {

dGame/dComponents/ModelComponent.h

@@ -147,17 +147,25 @@ public:
 	// Force sets the velocity to a value.
 	void SetVelocity(const NiPoint3& velocity) const;
 
-	// Attempts to set the angular velocity of the model.
-	// If the axis currently has a velocity of zero, returns true.
-	// If the axis is currently controlled by a behavior, returns false.
-	bool TrySetAngularVelocity(const NiPoint3& angularVelocity) const;
+	// Attempts to claim a world axis (0 = x, 1 = y, 2 = z) for rotation in direction (+1 or -1).
+	// Returns false if the axis is already controlled by a behavior.
+	bool TryStartRotation(const int axis, const float direction);
+
+	// Sets how many signed degrees the active rotation on axis has progressed and updates the entity.
+	void SetRotationProgress(const int axis, const float degrees);
+
+	// Releases the axis so another behavior can rotate it.
+	void StopRotation(const int axis);
+
+	// Degrees per second for rotation actions at the current speed.
+	float GetAngularSpeed() const noexcept { return BASE_ANGULAR_SPEED * m_Speed; }
 
 	void OnChatMessageReceived(const std::string& sMessage);
 
 	void OnHit();
 
 	// Sets the speed of the model
-	void SetSpeed(const float newSpeed) { m_Speed = newSpeed; }
+	void SetSpeed(const float newSpeed);
 
 	// Whether or not to restart at the end of the frame
 	void RestartAtEndOfFrame() { m_RestartAtEndOfFrame = true; }
@@ -172,6 +180,14 @@ public:
 
 	float GetSpeed() const noexcept { return m_Speed; }
 private:
+	// Degrees per second per unit of m_Speed
+	static constexpr float BASE_ANGULAR_SPEED = 15.0f;
+
+	// Sends the client-side angular velocity for the currently active rotation axes.
+	void SyncAngularVelocity() const;
+
+	// Clears all rotation state and makes rotation relative to newBase.
+	void ResetRotationState(const NiQuaternion& newBase);
 
 	// Loads a behavior from the database.
 	void LoadBehavior(const LWOOBJID behaviorID, const size_t index, const bool isIndexed);
@@ -220,4 +236,19 @@ private:
 
 	// Whether or not to restart at the end of the frame.
 	bool m_RestartAtEndOfFrame{ false };
+
+	// The rotation that m_RotationDegrees is applied on top of
+	NiQuaternion m_RotationBase = QuatUtils::IDENTITY;
+
+	// Accumulated signed degrees per world axis since m_RotationBase was set
+	NiPoint3 m_RotationDegrees{};
+
+	// m_RotationDegrees at the moment the current rotation on each axis started
+	NiPoint3 m_RotationActionStart{};
+
+	// Per axis -1, 0 or 1. Non-zero means a behavior currently owns rotation on that axis.
+	NiPoint3 m_RotationDirection{};
+
+	// Whether the client is sent an angular velocity to extrapolate rotation between updates
+	bool m_SendAngularVelocity{ true };
 };

dGame/dComponents/SimplePhysicsComponent.cpp

@@ -40,20 +40,11 @@ SimplePhysicsComponent::~SimplePhysicsComponent() {
 }
 
 void SimplePhysicsComponent::Update(const float deltaTime) {
-	if (m_Velocity != NiPoint3Constant::ZERO) {
-		m_Position += m_Velocity * deltaTime;
-		m_DirtyPosition = true;
-		Game::entityManager->SerializeEntity(m_Parent);
-	}
-
-	if (m_AngularVelocity != NiPoint3Constant::ZERO) {
-		m_Rotation.Normalize();
-		const auto vel = NiQuaternion::FromEulerAngles(m_AngularVelocity * deltaTime);
-		m_Rotation *= vel;
-		const auto euler = m_Rotation.GetEulerAngles();
-		m_DirtyPosition = true;
-		Game::entityManager->SerializeEntity(m_Parent);
-	}
+	// Rotation is driven by ModelComponent; angular velocity is only relayed to clients.
+	if (m_Velocity == NiPoint3Constant::ZERO) return;
+	m_Position += m_Velocity * deltaTime;
+	m_DirtyPosition = true;
+	Game::entityManager->SerializeEntity(m_Parent);
 }
 
 void SimplePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
@@ -102,17 +93,15 @@ bool SimplePhysicsComponent::OnGetObjectReportInfo(GameMessages::GetObjectReport
 	return true;
 }
 
-bool SimplePhysicsComponent::OnSetAngularVelocity(GameMessages::GameMsg& msg) {
-	auto& setAngVel = static_cast<GameMessages::SetAngularVelocity&>(msg);
+bool SimplePhysicsComponent::OnSetAngularVelocity(GameMessages::SetAngularVelocity& setAngVel) {
 	m_DirtyVelocity |= setAngVel.bForceFlagDirty || (m_AngularVelocity != setAngVel.angVelocity);
 	m_AngularVelocity = setAngVel.angVelocity;
-	LOG("Velocity is now %f %f %f", m_AngularVelocity.x, m_AngularVelocity.y, m_AngularVelocity.z);
+	LOG_DEBUG("Angular velocity is now %f %f %f", m_AngularVelocity.x, m_AngularVelocity.y, m_AngularVelocity.z);
 	Game::entityManager->SerializeEntity(m_Parent);
 	return true;
 }
 
-bool SimplePhysicsComponent::OnGetAngularVelocity(GameMessages::GameMsg& msg) {
-	auto& getAngVel = static_cast<GameMessages::GetAngularVelocity&>(msg);
+bool SimplePhysicsComponent::OnGetAngularVelocity(GameMessages::GetAngularVelocity& getAngVel) {
 	getAngVel.angVelocity = m_AngularVelocity;
 	return true;
 }

dGame/dComponents/SimplePhysicsComponent.h

@@ -22,6 +22,11 @@ enum class eClimbableType : int32_t {
 	CLIMBABLE_TYPE_WALL_STICK
 };
 
+namespace GameMessages {
+	struct SetAngularVelocity;
+	struct GetAngularVelocity;
+}
+
 
 /**
  * Component that serializes locations of entities to the client
@@ -61,8 +66,8 @@ public:
 	 */
 	void SetAngularVelocity(const NiPoint3& value) { m_AngularVelocity = value; m_DirtyVelocity = true; }
 
-	bool OnSetAngularVelocity(GameMessages::GameMsg& msg);
-	bool OnGetAngularVelocity(GameMessages::GameMsg& msg);
+	bool OnSetAngularVelocity(GameMessages::SetAngularVelocity& setAngVel);
+	bool OnGetAngularVelocity(GameMessages::GetAngularVelocity& getAngVel);
 
 	/**
 	 * Returns the physics motion state