Assignment 2 Submission

OpenGLEngine/OpenGLEngine/BungeeComponent.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BungeeComponent
+	{
+		BungeeComponent(float _springConstant = 10.0f, float _restLength = 10.0f, ECSEntity _connectedEntityA = ECSEntity(), ECSEntity _connectedEntityB = ECSEntity())
+			: springConstant(_springConstant), restLength(_restLength), connectedEntityA(_connectedEntityA), connectedEntityB(_connectedEntityB)
+		{
+
+		}
+
+		float springConstant;
+		float restLength;
+		ECSEntity connectedEntityA;
+		ECSEntity connectedEntityB;
+	};
+}

OpenGLEngine/OpenGLEngine/BungeeSystem.cpp

@@ -0,0 +1,50 @@
+#include "BungeeSystem.h"
+#include "TransformComponent.h"
+#include "ForceAccumulatorComponent.h"
+#include "InputEventSystem.h"
+
+namespace Reality
+{
+	BungeeSystem::BungeeSystem()
+	{
+		requireComponent<BungeeComponent>();
+	}
+
+	void BungeeSystem::Update(float deltaTime)
+	{
+		for (auto e : getEntities())
+		{
+			auto& bungee = e.getComponent<BungeeComponent>();
+
+			if (bungee.connectedEntityA.hasComponent<TransformComponent>()
+				&& bungee.connectedEntityB.hasComponent<TransformComponent>())
+			{
+				auto& transformA = bungee.connectedEntityA.getComponent<TransformComponent>();
+
+				auto& transformB = bungee.connectedEntityB.getComponent<TransformComponent>();
+
+				Vector3 relativePosition = transformA.position - transformB.position;
+
+				float length = glm::length(relativePosition);
+
+				if (!(length < bungee.restLength))
+				{
+					float deltaL = length - bungee.restLength;
+					Vector3 force = -glm::normalize(relativePosition);
+					force *= bungee.springConstant * deltaL;
+
+					if (bungee.connectedEntityA.hasComponent<ForceAccumulatorComponent>())
+						bungee.connectedEntityA.getComponent<ForceAccumulatorComponent>().AddForce(force);
+
+					if (bungee.connectedEntityB.hasComponent<ForceAccumulatorComponent>())
+						bungee.connectedEntityB.getComponent<ForceAccumulatorComponent>().AddForce(-force);
+
+					if (DEBUG_LOG_LEVEL > 0)
+					{
+						getWorld().data.renderUtil->DrawLine(transformA.position, transformB.position, deltaL > 0 ? Color::Red : Color::Green);
+					}
+				}
+			}
+		}
+	}
+}

OpenGLEngine/OpenGLEngine/BungeeSystem.h

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

OpenGLEngine/OpenGLEngine/BuoyancyComponent.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct BuoyancyComponent
+	{
+		BuoyancyComponent(float _maxDepth = 10.0f, float _volume = 10.0f, float _waterHeight = 0.0f, float _liquidDensity = 1000.0f)
+			: maxDepth(_maxDepth), volume(_volume), waterHeight(_waterHeight), liquidDensity(_liquidDensity)
+		{
+
+		}
+
+		float maxDepth;
+		float volume;
+		float waterHeight;
+		float liquidDensity;
+	};
+}

OpenGLEngine/OpenGLEngine/BuoyancySystem.cpp

@@ -0,0 +1,107 @@
+#include "BuoyancySystem.h"
+#include "TransformComponent.h"
+#include "ForceAccumulatorComponent.h"
+#include "ParticleComponent.h"
+#include "GravityForceComponent.h"
+namespace Reality
+{
+	BuoyancySystem::BuoyancySystem()
+	{
+		requireComponent<BuoyancyComponent>();
+		requireComponent<ForceAccumulatorComponent>();
+	}
+
+	void BuoyancySystem::Update(float deltaTime)
+	{
+		if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_UP) == GLFW_PRESS)
+		{
+			for (auto e : getEntities())
+			{
+				if (e.hasComponent<BuoyancyComponent>())
+				{
+					e.getComponent<BuoyancyComponent>().liquidDensity += 5;
+
+					if (e.getComponent<BuoyancyComponent>().liquidDensity >= 10000)
+					{
+						e.getComponent<BuoyancyComponent>().liquidDensity = 10000;
+					}
+
+					currentBuoyancyValue = e.getComponent<BuoyancyComponent>().liquidDensity;
+				}
+			}
+		}
+
+		if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_DOWN) == GLFW_PRESS)
+		{
+			for (auto e : getEntities())
+			{
+				if (e.hasComponent<BuoyancyComponent>())
+				{
+					e.getComponent<BuoyancyComponent>().liquidDensity -= 5;
+
+					if (e.getComponent<BuoyancyComponent>().liquidDensity <= 10)
+					{
+						e.getComponent<BuoyancyComponent>().liquidDensity = 10;
+					}
+
+					currentBuoyancyValue = e.getComponent<BuoyancyComponent>().liquidDensity;
+				}
+			}
+		}
+
+		for (auto e : getEntities())
+		{
+			auto& buoyancy = e.getComponent<BuoyancyComponent>();
+			auto& forceAcc = e.getComponent<ForceAccumulatorComponent>();
+
+			currentBuoyancyValue = buoyancy.liquidDensity;
+
+			if (e.hasComponent<TransformComponent>())
+			{
+				auto& transform = e.getComponent<TransformComponent>();
+
+				float depth = transform.position.y;
+
+				if (DEBUG_LOG_LEVEL > 0)
+				{
+					getWorld().data.renderUtil->DrawCube(Vector3(0, (buoyancy.waterHeight - buoyancy.maxDepth) / 2, -50), Vector3(width * 2, buoyancy.maxDepth, length * 2) , Quaternion(Vector3(1, 1, 1), Vector3(1, 1, 1) ), Color::Blue);
+				}
+
+				if (depth >= buoyancy.waterHeight || (transform.position.x >= width + 50 || transform.position.x <= -width - 50) || (transform.position.z >= length + 50 || transform.position.z <= -length - 50))
+				{
+
+				}
+				else
+				{
+					Vector3 force(0, 0, 0);
+
+					if (depth <= buoyancy.waterHeight - buoyancy.maxDepth)
+					{
+						force.y = buoyancy.liquidDensity * buoyancy.volume;
+						cout << force.y << endl;
+
+						forceAcc.AddForce(force);
+						if (DEBUG_LOG_LEVEL > 0)
+						{
+							getWorld().data.renderUtil->DrawLine(Vector3(transform.position.x, buoyancy.waterHeight, transform.position.z), transform.position, Color::Red);
+						}
+					}
+					else
+					{
+						float scale = depth + buoyancy.maxDepth <= 1 ? 1 : depth + buoyancy.maxDepth;
+
+						force.y = buoyancy.liquidDensity / (scale - buoyancy.waterHeight) * buoyancy.volume;
+						cout << force.y << endl;
+
+						forceAcc.AddForce(force);
+
+						if (DEBUG_LOG_LEVEL > 0)
+						{
+							getWorld().data.renderUtil->DrawLine(Vector3(transform.position.x, buoyancy.waterHeight, transform.position.z), transform.position, Color::Green);
+						}
+					}
+				}
+			}
+		}
+	}
+}

OpenGLEngine/OpenGLEngine/BuoyancySystem.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "ECSConfig.h"
+#include "TransformComponent.h"
+#include "BuoyancyComponent.h"
+
+namespace Reality
+{
+	class BuoyancySystem : public ECSSystem
+	{
+	public:
+		BuoyancySystem();
+		void Update(float deltaTime);
+
+		bool spawning = true;
+		float currentBuoyancyValue;
+		float width = 50;
+		float length = 50;
+	};
+}

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;

OpenGLEngine/OpenGLEngine/CableSystem.cpp

@@ -0,0 +1,49 @@
+#include "CableSystem.h"
+#include "TransformComponent.h"
+#include "ParticleContactEvent.h"
+
+namespace Reality
+{
+	CableSystem::CableSystem()
+	{
+		requireComponent<CableComponent>();
+	}
+
+	void CableSystem::Update(float deltaTime)
+	{
+		for (auto e : getEntities())
+		{
+			auto& cable = e.getComponent<CableComponent>();
+
+			if (cable.entityA.hasComponent<TransformComponent>() &&
+				cable.entityB.hasComponent<TransformComponent>())
+			{
+				auto& transformA = cable.entityA.getComponent<TransformComponent>();
+				auto& transformB = cable.entityB.getComponent<TransformComponent>();
+
+				Vector3 relativePos = transformA.position - transformB.position;
+				float length = glm::length(relativePos);
+
+				if (length > cable.maxLength)
+				{
+					Vector3 normal = -glm::normalize(relativePos);
+					float penetration = length - cable.maxLength;
+
+					getWorld().getEventManager().emitEvent<ParticleContactEvent>(
+						cable.entityA,
+						cable.entityB,
+						cable.restitution,
+						normal,
+						penetration
+						);
+				}
+
+				getWorld().data.renderUtil->DrawLine(
+					transformA.position,
+					transformB.position,
+					Color::Magenta
+				);
+			}
+		}
+	}
+}

OpenGLEngine/OpenGLEngine/CableSystem.h

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

OpenGLEngine/OpenGLEngine/DragForceComponent.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "ECSConfig.h"
+
+namespace Reality
+{
+	struct DragForceComponent
+	{
+		DragForceComponent(float _k1 = 0.0f, float _k2 = 0.0f)
+			: k1(_k1), k2(_k2)
+		{
+
+		}
+		float k1;
+		float k2;
+	};
+}

OpenGLEngine/OpenGLEngine/DragForceSystem.cpp

@@ -0,0 +1,29 @@
+#include "DragForceSystem.h"
+
+namespace Reality
+{
+	DragForceSystem::DragForceSystem()
+	{
+		requireComponent<ParticleComponent>();
+		requireComponent<ForceAccumulatorComponent>();
+		requireComponent<DragForceComponent>();
+	}
+
+	void DragForceSystem::Update(float deltaTime)
+	{
+		for (auto e : getEntities())
+		{
+			auto& particle = e.getComponent<ParticleComponent>();
+			auto& forceAcc = e.getComponent<ForceAccumulatorComponent>();
+			auto& drag = e.getComponent<DragForceComponent>();
+
+			float speed = glm::length(particle.velocity);
+			if (speed > 0)
+			{
+				Vector3 force = -glm::normalize(particle.velocity);
+				force *= drag.k1 * speed + drag.k2 * pow(speed, 2);
+				forceAcc.AddForce(force);
+			}
+		}
+	}
+}

OpenGLEngine/OpenGLEngine/DragForceSystem.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "ECSConfig.h"
+#include "ParticleComponent.h"
+#include "ForceAccumulatorComponent.h"
+#include "DragForceComponent.h"
+
+namespace Reality
+{
+	class DragForceSystem : public ECSSystem
+	{
+	public:
+		DragForceSystem();
+		void Update(float deltaTime);
+	};
+}

OpenGLEngine/OpenGLEngine/ECSConfig.h

@@ -4,6 +4,7 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #define RANDOM_FLOAT(LO, HI) LO + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (HI - LO)))
+#define DEBUG_LOG_LEVEL 3
 
 namespace Reality
 {