Zero G Assignment 2 Submission

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

@@ -0,0 +1,26 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct AeroControlComponent
+	{
+		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 controlSetting = 0;
+		float controlSpeed;
+	};
+}

OpenGLEngine/OpenGLEngine/AeroControlSystem.cpp

@@ -0,0 +1,57 @@
+#include "AeroControlSystem.h"
+
+namespace Reality
+{
+	AeroControlSystem::AeroControlSystem()
+	{
+		requireComponent<AeroSurfaceComponent>();
+		requireComponent<AeroControlComponent>();
+	}
+
+	void AeroControlSystem::Update(float deltaTime)
+	{
+		for (auto e : getEntities())
+		{
+			auto& surface = e.getComponent<AeroSurfaceComponent>();
+			auto& control = e.getComponent<AeroControlComponent>();
+
+			bool reset = true;
+
+			for (int key : control.positiveKeys)
+			{
+				if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, key) == GLFW_PRESS)
+				{
+					control.controlSetting += control.controlSpeed * deltaTime;
+					reset = false;
+				}
+			}
+
+			if (control.controlSetting > 1)
+			{
+				control.controlSetting = 1;
+			}
+
+			for (int key : control.negetiveKeys)
+			{
+				if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, key) == GLFW_PRESS)
+				{
+					control.controlSetting -= control.controlSpeed * deltaTime;
+					reset = false;
+				}
+			}
+
+			if (control.controlSetting < -1)
+			{
+				control.controlSetting = -1;
+			}
+
+			if (reset)
+			{
+				control.controlSetting = 0;
+			}
+
+			float t = (control.controlSetting + 1) * 0.5f;
+			surface.aerodynamicForce = t * control.aeroMinusOne + (1 - t) * control.aeroPlusOne;			
+		}
+	}
+}

OpenGLEngine/OpenGLEngine/AeroControlSystem.h

@@ -0,0 +1,14 @@
+#pragma once
+#include "ECSConfig.h"
+#include "AeroSurfaceComponent.h"
+#include "AeroControlComponent.h"
+
+namespace Reality
+{
+	class AeroControlSystem : public ECSSystem
+	{
+	public:
+		AeroControlSystem();
+		void Update(float deltaTime);
+	};
+}

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/BuoyancyComponent.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BuoyancyComponent
+	{
+		BuoyancyComponent(ECSEntity _targetEntity = ECSEntity(), Vector3 _localOffset = Vector3(0, 0, 0), Vector3 _dimensions = Vector3(1.0,1.0,1.0),
+			float _waterHeight = 0.0f, float _liquidDenisty = 5000, const std::vector<int>& _horizontalKeys = {})
+			:
+			targetEntity(_targetEntity), 
+			localOffset(_localOffset), 
+			dimensions(_dimensions), 
+			waterHeight(_waterHeight), 
+			liquidDensity(_liquidDenisty), 
+			currentDensity(_liquidDenisty),
+			HorizontalKeys(_horizontalKeys)
+		{
+
+		}
+
+		// using this to allow for custom dimensions of the buuoyancy component
+		ECSEntity targetEntity;
+		Vector3 dimensions;
+		float waterHeight;
+		float liquidDensity;
+		float currentDensity;
+		Vector3 localOffset;
+		Vector3 netForce = Vector3(0,0,0);
+
+		std::vector<int> HorizontalKeys;
+	};
+}