Assignment 3

OpenGLEngine/OpenGLEngine/AddTorqueFromCameraComponent.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct AddTorqueFromCameraComponent
+	{
+		AddTorqueFromCameraComponent(float _torqueScale = 10.0f)
+			: torqueScale(_torqueScale)
+		{
+
+		}
+		float torqueScale;
+	};
+}

OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.cpp

@@ -0,0 +1,35 @@
+#include "AddTorqueFromCameraSystem.h"
+#include "LifeTimeComponent.h"
+
+namespace Reality
+{
+	AddTorqueFromCameraSystem::AddTorqueFromCameraSystem()
+	{
+		requireComponent<TransformComponentV2>();
+		requireComponent<ForceAndTorqueAccumulatorComponent>();
+		requireComponent<AddTorqueFromCameraComponent>();
+	}
+
+	void AddTorqueFromCameraSystem::Update(float deltaTime)
+	{
+		if (!pressed && glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_E) == GLFW_PRESS)
+		{
+			for (auto e : getEntities())
+			{
+				auto& transform = e.getComponent<TransformComponentV2>();
+				auto& forceAndTorqueAcc = e.getComponent<ForceAndTorqueAccumulatorComponent>();
+				auto& addTorqueComp = e.getComponent<AddTorqueFromCameraComponent>();
+
+				Camera& cam = getWorld().data.renderUtil->camera;
+
+				Vector3 torque = glm::cross(cam.Position - transform.GetPosition(), cam.Front * addTorqueComp.torqueScale);
+				forceAndTorqueAcc.AddTorque(torque);
+			}
+			pressed = true;
+		}
+		else if(glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_E) == GLFW_RELEASE)
+		{
+			pressed = false;
+		}
+	}
+}

OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "ECSConfig.h"
+#include "TransformComponentV2.h"
+#include "ForceAndTorqueAccumulatorComponent.h"
+#include "AddTorqueFromCameraComponent.h"
+
+namespace Reality
+{
+	class AddTorqueFromCameraSystem : public ECSSystem
+	{
+	public:
+		AddTorqueFromCameraSystem();
+		void Update(float deltaTime);
+	private:
+		bool pressed = false;
+	};
+}

OpenGLEngine/OpenGLEngine/AeroControlComponent.h

@@ -1,19 +1,26 @@
 #pragma once
 #include "ECSConfig.h"
-#include <vector>
 
 namespace Reality
 {
 	struct AeroControlComponent
 	{
-		AeroControlComponent(std::vector<int> _positiveKeys = { GLFW_KEY_UP }, std::vector<int> _negetiveKeys = { GLFW_KEY_DOWN }, float _rate = 1)
-			:positiveKeys(_positiveKeys), negetiveKeys(_negetiveKeys), rate(_rate)
+		AeroControlComponent(Vector3 _aeroPlusOne = Vector3(0, 0, 0), Vector3 _aeroMinusOne = Vector3(0, 0, 0),
+			const std::vector<int>& _positiveKeys = {}, const std::vector<int>& _negetiveKeys = {},
+			float _controlSpeed = 1)
+			:aeroPlusOne(_aeroPlusOne),
+			aeroMinusOne(_aeroMinusOne),
+			positiveKeys(_positiveKeys),
+			negetiveKeys(_negetiveKeys),
+			controlSpeed(_controlSpeed)
 		{
 
 		}
-
+		Vector3 aeroPlusOne;
+		Vector3 aeroMinusOne;
 		std::vector<int> positiveKeys;
 		std::vector<int> negetiveKeys;
-		float rate;
+		float controlSetting = 0;
+		float controlSpeed;
 	};
 }

OpenGLEngine/OpenGLEngine/AeroControlSystem.cpp

@@ -4,43 +4,54 @@ namespace Reality
 {
 	AeroControlSystem::AeroControlSystem()
 	{
-		requireComponent<AeroMinMaxComponent>();
+		requireComponent<AeroSurfaceComponent>();
 		requireComponent<AeroControlComponent>();
 	}
 
 	void AeroControlSystem::Update(float deltaTime)
 	{
-		pKey = false;
-		nKey = false;
 		for (auto e : getEntities())
 		{
-			auto& aero = e.getComponent<AeroMinMaxComponent>();
+			auto& surface = e.getComponent<AeroSurfaceComponent>();
 			auto& control = e.getComponent<AeroControlComponent>();
 
-			for (auto key : control.positiveKeys)
+			bool reset = true;
+
+			for (int key : control.positiveKeys)
 			{
 				if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, key) == GLFW_PRESS)
 				{
-					aero.controlSetting += control.rate * deltaTime;
-					pKey = true;
+					control.controlSetting += control.controlSpeed * deltaTime;
+					reset = false;
 				}
 			}
-
-			for (auto key : control.negetiveKeys)
+
+			if (control.controlSetting > 1)
+			{
+				control.controlSetting = 1;
+			}
+
+			for (int key : control.negetiveKeys)
 			{
 				if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, key) == GLFW_PRESS)
 				{
-					aero.controlSetting -= control.rate * deltaTime;
-					nKey = true;
+					control.controlSetting -= control.controlSpeed * deltaTime;
+					reset = false;
 				}
 			}
 
-			if (!pKey && !nKey)
+			if (control.controlSetting < -1)
+			{
+				control.controlSetting = -1;
+			}
+
+			if (reset)
 			{
-				aero.controlSetting = 0;
+				control.controlSetting = 0;
 			}
 
-			aero.controlSetting = glm::clamp(aero.controlSetting, -1.0f, 1.0f);
+			float t = (control.controlSetting + 1) * 0.5f;
+			surface.aerodynamicForce = t * control.aeroMinusOne + (1 - t) * control.aeroPlusOne;			
 		}
 	}
 }

OpenGLEngine/OpenGLEngine/AeroControlSystem.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "ECSConfig.h"
-#include "AeroMinMaxComponent.h"
+#include "AeroSurfaceComponent.h"
 #include "AeroControlComponent.h"
 
 namespace Reality
@@ -10,8 +10,5 @@ namespace Reality
 	public:
 		AeroControlSystem();
 		void Update(float deltaTime);
-	private:
-		bool pKey = false;
-		bool nKey = false;
 	};
 }

OpenGLEngine/OpenGLEngine/AeroSurfaceComponent.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct AeroSurfaceComponent
+	{
+		AeroSurfaceComponent(ECSEntity _targetEntity = ECSEntity(), Vector3 _aerodynamicForce = Vector3(0, 0, 0),
+			Vector3 _localOffset = Vector3(0, 0, 0))
+			:targetEntity(_targetEntity),
+			aerodynamicForce(_aerodynamicForce),
+			localOffset(_localOffset)
+		{
+
+		}
+		ECSEntity targetEntity;
+		Vector3 aerodynamicForce;
+		Vector3 localOffset;
+	};
+}

OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.cpp

@@ -0,0 +1,48 @@
+#include "AeroSurfaceSystem.h"
+#include "RigidbodyComponent.h"
+#include "ForceAndTorqueAccumulatorComponent.h"
+
+namespace Reality
+{
+	AeroSurfaceSystem::AeroSurfaceSystem()
+	{
+		requireComponent<TransformComponentV2>();
+		requireComponent<AeroSurfaceComponent>();
+	}
+
+	void AeroSurfaceSystem::Update(float deltaTime)
+	{
+		for (auto e : getEntities())
+		{
+			auto& surfaceTransform = e.getComponent<TransformComponentV2>();
+			auto& aero = e.getComponent<AeroSurfaceComponent>();
+
+			if (aero.targetEntity.hasComponent<TransformComponentV2>() &&
+				aero.targetEntity.hasComponent<RigidbodyComponent>() &&
+				aero.targetEntity.hasComponent<ForceAndTorqueAccumulatorComponent>())
+			{
+				auto& targetTransform = aero.targetEntity.getComponent<TransformComponentV2>();
+				auto& rigidbody = aero.targetEntity.getComponent<RigidbodyComponent>();
+				auto& forceAndTorque = aero.targetEntity.getComponent<ForceAndTorqueAccumulatorComponent>();
+
+				// HACK: For lack of scene graph
+				Vector3 worldSurfacePosition = targetTransform.LocalToWorldPosition(aero.localOffset);
+				surfaceTransform.SetPosition(worldSurfacePosition);
+				surfaceTransform.SetOrientation(targetTransform.GetOrientation());
+				getWorld().data.renderUtil->DrawCube(surfaceTransform.GetPosition(),
+					Vector3(1, 1, 1),
+					surfaceTransform.GetOrientation());
+
+				Vector3 force = CalculateWorldAerodynamicForce(aero.aerodynamicForce, targetTransform);
+				forceAndTorque.AddForceAtPoint(force,
+					surfaceTransform.GetPosition(),
+					targetTransform.GetPosition());
+			}
+		}
+	}
+
+	const Vector3 & AeroSurfaceSystem::CalculateWorldAerodynamicForce(const Vector3& localAeroForce, TransformComponentV2& transform)
+	{
+		return transform.LocalToWorldDirection(localAeroForce);
+	}
+}

OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "ECSConfig.h"
+#include "TransformComponentV2.h"
+#include "AeroSurfaceComponent.h"
+
+namespace Reality
+{
+	class AeroSurfaceSystem : public ECSSystem
+	{
+	public:
+		AeroSurfaceSystem();
+		void Update(float deltaTime);
+		Vector3 windVelocity = Vector3(0, 0, 0);
+	private:
+		const Vector3& CalculateWorldAerodynamicForce(const Vector3& localAeroForce,
+			TransformComponentV2& transform);
+	};
+}

OpenGLEngine/OpenGLEngine/BuoyancyCenter2Component.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BuoyancyCenter2Component
+	{
+		BuoyancyCenter2Component(Vector3 _positionOffset = Vector3(0,0,0), float _maxDepth = 1.0f, float _volume = 1.0f)
+			: positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume)
+		{
+
+		}
+
+		Vector3 positionOffset;
+		float maxDepth;
+		float volume;
+	};
+}

OpenGLEngine/OpenGLEngine/BuoyancyCenter3Component.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BuoyancyCenter3Component
+	{
+		BuoyancyCenter3Component(Vector3 _positionOffset = Vector3(0, 0, 0), float _maxDepth = 1.0f, float _volume = 1.0f)
+			: positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume)
+		{
+
+		}
+
+		Vector3 positionOffset;
+		float maxDepth;
+		float volume;
+	};
+}

OpenGLEngine/OpenGLEngine/BuoyancyCenter4Component.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BuoyancyCenter4Component
+	{
+		BuoyancyCenter4Component(Vector3 _positionOffset = Vector3(0, 0, 0), float _maxDepth = 1.0f, float _volume = 1.0f)
+			: positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume)
+		{
+
+		}
+
+		Vector3 positionOffset;
+		float maxDepth;
+		float volume;
+	};
+}

OpenGLEngine/OpenGLEngine/BuoyancyCenterComponent.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BuoyancyCenterComponent
+	{
+		BuoyancyCenterComponent(Vector3 _positionOffset = Vector3(0, 0, 0), float _maxDepth = 1.0f, float _volume = 1.0f)
+			: positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume)
+		{
+
+		}
+
+		Vector3 positionOffset;
+		float maxDepth;
+		float volume;
+	};
+}

OpenGLEngine/OpenGLEngine/CableComponent.h

@@ -1,11 +1,21 @@
 #pragma once
 #include "ECSConfig.h"
+
 namespace Reality
 {
 	struct CableComponent
 	{
-		CableComponent(ECSEntity a = ECSEntity(), ECSEntity b = ECSEntity(), float _maxLength = 10, float _restitution = 1.0f)
-			: entityA(a), entityB(b), maxLength(_maxLength), restitution(_restitution){}
+		CableComponent(ECSEntity a = ECSEntity(),
+			ECSEntity b = ECSEntity(),
+			float _maxLength = 10,
+			float _restitution = 1)
+			: entityA(a),
+			entityB(b),
+			maxLength(_maxLength),
+			restitution(_restitution)
+		{
+
+		}
 		ECSEntity entityA;
 		ECSEntity entityB;
 		float maxLength;