diff --git a/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraComponent.h b/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraComponent.h new file mode 100644 index 0000000..1da6028 --- /dev/null +++ b/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; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.cpp b/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.cpp new file mode 100644 index 0000000..be862b6 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.cpp @@ -0,0 +1,35 @@ +#include "AddTorqueFromCameraSystem.h" +#include "LifeTimeComponent.h" + +namespace Reality +{ + AddTorqueFromCameraSystem::AddTorqueFromCameraSystem() + { + requireComponent(); + requireComponent(); + requireComponent(); + } + + 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(); + auto& forceAndTorqueAcc = e.getComponent(); + auto& addTorqueComp = e.getComponent(); + + 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; + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.h b/OpenGLEngine/OpenGLEngine/AddTorqueFromCameraSystem.h new file mode 100644 index 0000000..b6a638f --- /dev/null +++ b/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; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/AeroControlComponent.h b/OpenGLEngine/OpenGLEngine/AeroControlComponent.h index a918690..4de2a53 100644 --- a/OpenGLEngine/OpenGLEngine/AeroControlComponent.h +++ b/OpenGLEngine/OpenGLEngine/AeroControlComponent.h @@ -1,19 +1,26 @@ #pragma once #include "ECSConfig.h" -#include namespace Reality { struct AeroControlComponent { - AeroControlComponent(std::vector _positiveKeys = { GLFW_KEY_UP }, std::vector _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& _positiveKeys = {}, const std::vector& _negetiveKeys = {}, + float _controlSpeed = 1) + :aeroPlusOne(_aeroPlusOne), + aeroMinusOne(_aeroMinusOne), + positiveKeys(_positiveKeys), + negetiveKeys(_negetiveKeys), + controlSpeed(_controlSpeed) { } - + Vector3 aeroPlusOne; + Vector3 aeroMinusOne; std::vector positiveKeys; std::vector negetiveKeys; - float rate; + float controlSetting = 0; + float controlSpeed; }; } diff --git a/OpenGLEngine/OpenGLEngine/AeroControlSystem.cpp b/OpenGLEngine/OpenGLEngine/AeroControlSystem.cpp index 98b7cab..85f643d 100644 --- a/OpenGLEngine/OpenGLEngine/AeroControlSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/AeroControlSystem.cpp @@ -4,43 +4,54 @@ namespace Reality { AeroControlSystem::AeroControlSystem() { - requireComponent(); + requireComponent(); requireComponent(); } void AeroControlSystem::Update(float deltaTime) { - pKey = false; - nKey = false; for (auto e : getEntities()) { - auto& aero = e.getComponent(); + auto& surface = e.getComponent(); auto& control = e.getComponent(); - 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; } } } diff --git a/OpenGLEngine/OpenGLEngine/AeroControlSystem.h b/OpenGLEngine/OpenGLEngine/AeroControlSystem.h index 27b8ec1..1d2b69c 100644 --- a/OpenGLEngine/OpenGLEngine/AeroControlSystem.h +++ b/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; }; } diff --git a/OpenGLEngine/OpenGLEngine/AeroSurfaceComponent.h b/OpenGLEngine/OpenGLEngine/AeroSurfaceComponent.h new file mode 100644 index 0000000..d4b1c04 --- /dev/null +++ b/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; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.cpp b/OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.cpp new file mode 100644 index 0000000..326b028 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.cpp @@ -0,0 +1,48 @@ +#include "AeroSurfaceSystem.h" +#include "RigidbodyComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" + +namespace Reality +{ + AeroSurfaceSystem::AeroSurfaceSystem() + { + requireComponent(); + requireComponent(); + } + + void AeroSurfaceSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& surfaceTransform = e.getComponent(); + auto& aero = e.getComponent(); + + if (aero.targetEntity.hasComponent() && + aero.targetEntity.hasComponent() && + aero.targetEntity.hasComponent()) + { + auto& targetTransform = aero.targetEntity.getComponent(); + auto& rigidbody = aero.targetEntity.getComponent(); + auto& forceAndTorque = aero.targetEntity.getComponent(); + + // 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); + } +} diff --git a/OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.h b/OpenGLEngine/OpenGLEngine/AeroSurfaceSystem.h new file mode 100644 index 0000000..b186ab1 --- /dev/null +++ b/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); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/BungeeComponent.h b/OpenGLEngine/OpenGLEngine/BungeeComponent.h new file mode 100644 index 0000000..926683a --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BungeeComponent.h @@ -0,0 +1,26 @@ +#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; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/BungeeSystem.cpp b/OpenGLEngine/OpenGLEngine/BungeeSystem.cpp new file mode 100644 index 0000000..3d634cb --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BungeeSystem.cpp @@ -0,0 +1,153 @@ +#include "BungeeSystem.h" +#include "TransformComponent.h" +#include "ForceAccumulatorComponent.h" + +namespace Reality +{ + BungeeSystem::BungeeSystem() + { + requireComponent(); + //requireComponent(); + } + + void BungeeSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& bungee = e.getComponent(); + //getWorld().data.renderUtil->RenderText(bungee.connectedEntityB.toString(), 200.0f, 200.0f, 1.0f, Color(1, 0, 1, 1)); + // Paired Bungees + if (!e.hasComponent()) { + //if (bungee.connectedEntityB.hasComponent()) { + //if (bungee.connectedEntityB.getIndex() != 0) { + + //getWorld().data.renderUtil->RenderText(bungee.connectedEntityB.toString(), 25.0f, 25.0f, 1.0f, Color(1, 1, 1, 1)); + if (bungee.connectedEntityA.hasComponent() + && bungee.connectedEntityB.hasComponent()) + { + float deltaL = 0; + + auto& transformA = bungee.connectedEntityA.getComponent(); + auto& transformB = bungee.connectedEntityB.getComponent(); + + Vector3 relativePosition = transformA.position - transformB.position; + float length = glm::length(relativePosition); + + if (length <= bungee.restLength) + { + float g = 1.0f / (1.0f + pow(abs(0), 0.5f)); + float r = 1 - g; + + Color col = Color(r, g, 0, 1); + + float deltaLength = length / 10.0f; + Vector3 direction = -glm::normalize(relativePosition); + for (int i = 0; i < 10; i++) + { + getWorld().data.renderUtil->DrawCube( + transformA.position + (float)i * deltaLength * direction, + Vector3(1.0f, 1.0f, 1.0f) * min((bungee.restLength / 20.0f), 100.0f), Vector3(0, 0, 0), col); + } + getWorld().data.renderUtil->DrawLine(transformA.position, transformB.position, + col); + return; + } + + if (length > 0) + { + deltaL = length - bungee.restLength; + + Vector3 force = -glm::normalize(relativePosition); + force *= bungee.springConstant * deltaL; + + /*if (bungee.connectedEntityA.hasComponent()) + { + bungee.connectedEntityA.getComponent().AddForce(force); + }*/ + if (bungee.connectedEntityB.hasComponent()) + { + bungee.connectedEntityB.getComponent().AddForce(-force); + } + + float g = 1.0f / (1.0f + pow(abs(deltaL), 0.5f)); + float r = 1 - g; + + Color col = Color(r, g, 0, 1); + + float deltaLength = length / 10.0f; + Vector3 direction = -glm::normalize(relativePosition); + for (int i = 0; i < 10; i++) + { + getWorld().data.renderUtil->DrawCube( + transformA.position + (float)i * deltaLength * direction, + Vector3(1.0f, 1.0f, 1.0f) * min((bungee.restLength / 20.0f), 100.0f), Vector3(0, 0, 0), col); + } + getWorld().data.renderUtil->DrawLine(transformA.position, transformB.position, + col); + } + } + } + else { + auto& bungeeTransform = e.getComponent(); + if (bungee.connectedEntityA.hasComponent() + && bungee.connectedEntityA.hasComponent()) + { + float deltaL = 0; + + auto& transformA = bungee.connectedEntityA.getComponent(); + auto& forceAcc = bungee.connectedEntityA.getComponent(); + + Vector3 relativePosition = transformA.position - bungeeTransform.position; + float length = glm::length(relativePosition); + + if (length <= bungee.restLength) + { + float g = 1.0f / (1.0f + pow(abs(deltaL), 0.5f)); + float r = 1 - g; + + Color col = Color(r, g, 0, 1); + + float deltaLength = length / 10.0f; + Vector3 direction = -glm::normalize(relativePosition); + for (int i = 0; i < 10; i++) + { + getWorld().data.renderUtil->DrawCube( + transformA.position + (float)i * deltaLength * direction, + Vector3(1.0f, 1.0f, 1.0f) * min((bungee.restLength / 20.0f), 100.0f), Vector3(0, 0, 0), col); + } + getWorld().data.renderUtil->DrawLine(transformA.position, bungeeTransform.position, + col); + return; + } + + if (length > 0) + { + deltaL = length - bungee.restLength; + + Vector3 force = -glm::normalize(relativePosition); + force *= bungee.springConstant * deltaL; + forceAcc.AddForce(force); + } + float g = 1.0f / (1.0f + pow(abs(deltaL), 0.5f)); + float r = 1 - g; + + Color col = Color(r, g, 0, 1); + + float deltaLength = length / 10.0f; + Vector3 direction = -glm::normalize(relativePosition); + for (int i = 0; i < 10; i++) + { + getWorld().data.renderUtil->DrawCube( + transformA.position + (float)i * deltaLength * direction, + Vector3(1.0f, 1.0f, 1.0f) * min((bungee.restLength / 20.0f), 100.0f), Vector3(0, 0, 0), col); + } + getWorld().data.renderUtil->DrawLine(transformA.position, bungeeTransform.position, + col); + + } + } + + + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/BungeeSystem.h b/OpenGLEngine/OpenGLEngine/BungeeSystem.h new file mode 100644 index 0000000..c487a72 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BungeeSystem.h @@ -0,0 +1,13 @@ +#pragma once +#include "ECSConfig.h" +#include "BungeeComponent.h" + +namespace Reality +{ + class BungeeSystem : public ECSSystem + { + public: + BungeeSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/BuoyancyComponent.h b/OpenGLEngine/OpenGLEngine/BuoyancyComponent.h new file mode 100644 index 0000000..41c3405 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancyComponent.h @@ -0,0 +1,23 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct BuoyancyComponent + { + BuoyancyComponent(float _maxDepth = 10.0f, float _volume = 100.0f, float _waterHeight = 10.0f, ECSEntity _buoy = ECSEntity(), float _density = 1000.0f) + : maxDepth(_maxDepth), + volume(_volume), + waterHeight(_waterHeight), + buoyEntity(_buoy), + density(_density) + { + + } + float maxDepth, + volume, + waterHeight, + density; + ECSEntity buoyEntity; + }; +} \ No newline at end of file diff --git a/OpenGLEngine/OpenGLEngine/BuoyancySystem.cpp b/OpenGLEngine/OpenGLEngine/BuoyancySystem.cpp new file mode 100644 index 0000000..8de3a72 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancySystem.cpp @@ -0,0 +1,74 @@ +#include "BuoyancySystem.h" +#include "TransformComponentV2.h" +#include "ForceAccumulatorComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" + +namespace Reality +{ + BuoyancySystem::BuoyancySystem() + { + requireComponent(); + + } + + void BuoyancySystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& buoyancy = e.getComponent(); + auto& waterTransform = e.getComponent(); + + if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_UP)) + { + buoyancy.density += 1.0f; + } + if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_DOWN)) + { + buoyancy.density -= 1.0f; + if (buoyancy.density <= 0.0f) + buoyancy.density = 0.0f; + } + + if (buoyancy.buoyEntity.hasComponent()) + { + auto& buoyTransform = buoyancy.buoyEntity.getComponent(); + + getWorld().data.renderUtil->DrawLine(Vector3(0.0f, buoyancy.waterHeight + buoyancy.maxDepth, 0.0f), buoyTransform.GetPosition(), + Color(1, 0, 0, 1)); + + //getWorld().data.renderUtil->DrawSphere(Vector3(0.0f), 30.0f, Color(0, 0, 1, 1)); + getWorld().data.renderUtil->DrawCube(Vector3(0.0f, buoyancy.waterHeight + buoyancy.maxDepth - 15.0f, 0.0f), Vector3(50.0f, 30.0f, 50.0f), Vector3(0, 0, 0), Color(0, 0, 1, 1)); + + getWorld().data.renderUtil->RenderText(std::to_string(buoyancy.density), 0.0f, 0.0f, 1.0f, Color(1, 1, 1, 1)); + + //float depth = buoyTransform.position.y; + float depth = buoyTransform.GetPosition().y; + Vector3 force = Vector3(0, 0, 0); + + if (depth >= buoyancy.waterHeight + buoyancy.maxDepth) + { + return; + } + + if (depth <= buoyancy.waterHeight - buoyancy.maxDepth) + { + force.y = buoyancy.density * buoyancy.volume; + if (buoyancy.buoyEntity.hasComponent()) + { + buoyancy.buoyEntity.getComponent().AddForce(-force); + } + return; + } + + force.y = buoyancy.density * buoyancy.volume * + (depth - buoyancy.maxDepth - buoyancy.waterHeight) / 2 * buoyancy.maxDepth; + if (buoyancy.buoyEntity.hasComponent()) + { + buoyancy.buoyEntity.getComponent().AddForce(-force); + } + + } + + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/BuoyancySystem.h b/OpenGLEngine/OpenGLEngine/BuoyancySystem.h new file mode 100644 index 0000000..609dc4c --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancySystem.h @@ -0,0 +1,13 @@ +#pragma once +#include "ECSConfig.h" +#include "BuoyancyComponent.h" + +namespace Reality +{ + class BuoyancySystem : public ECSSystem + { + public: + BuoyancySystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/CableComponent.h b/OpenGLEngine/OpenGLEngine/CableComponent.h index 07d09c6..87972d5 100644 --- a/OpenGLEngine/OpenGLEngine/CableComponent.h +++ b/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; diff --git a/OpenGLEngine/OpenGLEngine/CableSystem.cpp b/OpenGLEngine/OpenGLEngine/CableSystem.cpp new file mode 100644 index 0000000..4aa3143 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/CableSystem.cpp @@ -0,0 +1,49 @@ +#include "CableSystem.h" +#include "TransformComponent.h" +#include "ParticleContactEvent.h" + +namespace Reality +{ + CableSystem::CableSystem() + { + requireComponent(); + } + + void CableSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& cable = e.getComponent(); + + if (cable.entityA.hasComponent() && + cable.entityB.hasComponent()) + { + auto& transformA = cable.entityA.getComponent(); + auto& transformB = cable.entityB.getComponent(); + + 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( + cable.entityA, + cable.entityB, + cable.restitution, + normal, + penetration + ); + } + + getWorld().data.renderUtil->DrawLine( + transformA.position, + transformB.position, + Color::Magenta + ); + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/CableSystem.h b/OpenGLEngine/OpenGLEngine/CableSystem.h new file mode 100644 index 0000000..a888363 --- /dev/null +++ b/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); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/DragComponent.h b/OpenGLEngine/OpenGLEngine/DragComponent.h new file mode 100644 index 0000000..c802f1f --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/DragComponent.h @@ -0,0 +1,16 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct DragComponent + { + DragComponent(float _linearDrag = 0.3f, float _angularDrag = 0.3f) + :linearDrag(_linearDrag), angularDrag(_angularDrag) + { + + } + float linearDrag; + float angularDrag; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/DragForceComponent.h b/OpenGLEngine/OpenGLEngine/DragForceComponent.h new file mode 100644 index 0000000..dec367f --- /dev/null +++ b/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; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/DragForceSystem.cpp b/OpenGLEngine/OpenGLEngine/DragForceSystem.cpp new file mode 100644 index 0000000..591e326 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/DragForceSystem.cpp @@ -0,0 +1,29 @@ +#include "DragForceSystem.h" + +namespace Reality +{ + DragForceSystem::DragForceSystem() + { + requireComponent(); + requireComponent(); + requireComponent(); + } + + void DragForceSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& particle = e.getComponent(); + auto& forceAcc = e.getComponent(); + auto& drag = e.getComponent(); + + 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); + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/DragForceSystem.h b/OpenGLEngine/OpenGLEngine/DragForceSystem.h new file mode 100644 index 0000000..d3f21e8 --- /dev/null +++ b/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); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/DragSystem.cpp b/OpenGLEngine/OpenGLEngine/DragSystem.cpp new file mode 100644 index 0000000..8b51198 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/DragSystem.cpp @@ -0,0 +1,22 @@ +#include "DragSystem.h" + +namespace Reality +{ + DragSystem::DragSystem() + { + requireComponent(); + requireComponent(); + } + + void DragSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& rigidbody = e.getComponent(); + auto& drag = e.getComponent(); + + rigidbody.velocity *= pow(1.0f - drag.linearDrag, deltaTime); + rigidbody.angularVelocity *= pow(1.0f - drag.angularDrag, deltaTime); + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/DragSystem.h b/OpenGLEngine/OpenGLEngine/DragSystem.h new file mode 100644 index 0000000..5636485 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/DragSystem.h @@ -0,0 +1,14 @@ +#pragma once +#include "ECSConfig.h" +#include "RigidbodyComponent.h" +#include "DragComponent.h" + +namespace Reality +{ + class DragSystem : public ECSSystem + { + public: + DragSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ECSConfig.h b/OpenGLEngine/OpenGLEngine/ECSConfig.h index dee62f8..08fdbcd 100644 --- a/OpenGLEngine/OpenGLEngine/ECSConfig.h +++ b/OpenGLEngine/OpenGLEngine/ECSConfig.h @@ -4,6 +4,7 @@ #include #include #define RANDOM_FLOAT(LO, HI) LO + static_cast (rand()) / (static_cast (RAND_MAX / (HI - LO))) +#define DEBUG_LOG_LEVEL 3 namespace Reality { diff --git a/OpenGLEngine/OpenGLEngine/FireworksComponent.h b/OpenGLEngine/OpenGLEngine/FireworksComponent.h new file mode 100644 index 0000000..f988802 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/FireworksComponent.h @@ -0,0 +1,20 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct FireworksComponent + { + FireworksComponent(int _numberOfParticles = 6, int _generation = 3, float _spawnTime = 3, float _velocityScale = 10.0f, Color _color = Color::Green) + :numberOfParticles(_numberOfParticles), generation(_generation), spawnTime(_spawnTime), velocityScale(_velocityScale),color(_color), timer(0.0f) + { + + } + int numberOfParticles; + int generation; + float spawnTime; + float timer; + float velocityScale; + Color color; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/FireworksSystem.cpp b/OpenGLEngine/OpenGLEngine/FireworksSystem.cpp new file mode 100644 index 0000000..3d24430 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/FireworksSystem.cpp @@ -0,0 +1,60 @@ +#include "FireworksSystem.h" +#include "ParticleComponent.h" +#include "ForceAccumulatorComponent.h" +#include "GravityForceComponent.h" + +namespace Reality +{ + FireworksSystem::FireworksSystem() + { + requireComponent(); + requireComponent(); + } + + void FireworksSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& transform = e.getComponent(); + auto& fireworks = e.getComponent(); + + fireworks.timer += deltaTime; + if (fireworks.timer > fireworks.spawnTime) + { + if (fireworks.generation > 0) + { + float deltaAngle = 2 * AI_MATH_PI / fireworks.numberOfParticles; + for (int i = 0; i < fireworks.numberOfParticles; i++) + { + auto particle = getWorld().createEntity(); + particle.addComponent(transform.position); + float angle = i * deltaAngle; + Vector3 velocity = Vector3(0, 1, 0); + velocity.x = cos(angle); + velocity.z = sin(angle); + velocity *= fireworks.velocityScale; + particle.addComponent(velocity); + particle.addComponent(); + particle.addComponent(); + float colorAlpha = (float)i / (float)fireworks.numberOfParticles; + particle.addComponent( + fireworks.numberOfParticles, + fireworks.generation - 1, + fireworks.spawnTime + RANDOM_FLOAT(-0.3f, 0.3f), + fireworks.velocityScale, + Color(colorAlpha, 0, 1 - colorAlpha) + ); + + } + } + e.kill(); + } + + + if (DEBUG_LOG_LEVEL > 0) + { + getWorld().data.renderUtil->DrawSphere(transform.position, 1.0f, fireworks.color); + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/FireworksSystem.h b/OpenGLEngine/OpenGLEngine/FireworksSystem.h new file mode 100644 index 0000000..c8bdc7f --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/FireworksSystem.h @@ -0,0 +1,14 @@ +#pragma once +#include "ECSConfig.h" +#include "TransformComponent.h" +#include "FireworksComponent.h" + +namespace Reality +{ + class FireworksSystem : public ECSSystem + { + public: + FireworksSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/FixedSpringComponent.h b/OpenGLEngine/OpenGLEngine/FixedSpringComponent.h index b8b312b..dabd2d8 100644 --- a/OpenGLEngine/OpenGLEngine/FixedSpringComponent.h +++ b/OpenGLEngine/OpenGLEngine/FixedSpringComponent.h @@ -5,10 +5,17 @@ namespace Reality { struct FixedSpringComponent { - FixedSpringComponent(float _springConstant = 10, float _restLength = 10, ECSEntity e = ECSEntity()) - :springConstant(_springConstant), restLength(_restLength), entity(e){} + FixedSpringComponent(float _springConstant = 10.0f, + float _restLength = 10.0f, + ECSEntity _connectedEntity = ECSEntity()) + : springConstant(_springConstant), + restLength(_restLength), + connectedEntity(_connectedEntity) + { + + } float springConstant; float restLength; - ECSEntity entity; + ECSEntity connectedEntity; }; } diff --git a/OpenGLEngine/OpenGLEngine/FixedSpringSystem.cpp b/OpenGLEngine/OpenGLEngine/FixedSpringSystem.cpp new file mode 100644 index 0000000..ae5a0f6 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/FixedSpringSystem.cpp @@ -0,0 +1,55 @@ +#include "FixedSpringSystem.h" +#include "ForceAccumulatorComponent.h" + +namespace Reality +{ + FixedSpringSystem::FixedSpringSystem() + { + requireComponent(); + requireComponent(); + } + + void FixedSpringSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& springTransform = e.getComponent(); + auto& spring = e.getComponent(); + + if (spring.connectedEntity.hasComponent() + && spring.connectedEntity.hasComponent()) + { + auto& forceAcc = spring.connectedEntity.getComponent(); + auto& transform = spring.connectedEntity.getComponent(); + + Vector3 relativePosition = transform.position - springTransform.position; + float length = glm::length(relativePosition); + if (length > 0) + { + float deltaL = length - spring.restLength; + Vector3 force = -glm::normalize(relativePosition); + force *= spring.springConstant * deltaL; + forceAcc.AddForce(force); + + float g = 1.0f / (1.0f + pow(abs(deltaL), 0.5f)); + float r = 1 - g; + + Color col = Color(r, g, 0, 1); + + float deltaLength = length / 10.0f; + Vector3 direction = -glm::normalize(relativePosition); + for (int i = 0; i < 10; i++) + { + getWorld().data.renderUtil->DrawCube( + transform.position + (float)i * deltaLength * direction, + Vector3(1.0f, 1.0f, 1.0f) * min((spring.restLength / 20.0f), 100.0f), Vector3(0, 0, 0), col); + } + + getWorld().data.renderUtil->DrawLine(springTransform.position, transform.position, + col); + } + + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/FixedSpringSystem.h b/OpenGLEngine/OpenGLEngine/FixedSpringSystem.h new file mode 100644 index 0000000..89968b1 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/FixedSpringSystem.h @@ -0,0 +1,14 @@ +#pragma once +#include "ECSConfig.h" +#include "TransformComponent.h" +#include "FixedSpringComponent.h" + +namespace Reality +{ + class FixedSpringSystem : public ECSSystem + { + public: + FixedSpringSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ForceAccumulatorComponent.h b/OpenGLEngine/OpenGLEngine/ForceAccumulatorComponent.h new file mode 100644 index 0000000..62ca949 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ForceAccumulatorComponent.h @@ -0,0 +1,30 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct ForceAccumulatorComponent + { + ForceAccumulatorComponent(float _mass = 1.0f) + : inverseMass(1.0f / _mass), forceAccumulator(Vector3(0, 0, 0)) + { + + } + float inverseMass; + + inline void AddForce(Vector3 force) + { + forceAccumulator += force; + } + inline void ResetAccumulator() + { + forceAccumulator = Vector3(0, 0, 0); + } + inline Vector3 GetAccumulatedForce() + { + return forceAccumulator; + } + private: + Vector3 forceAccumulator; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.cpp b/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.cpp index d1bbb3d..b4f7c21 100644 --- a/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.cpp @@ -1,21 +1,22 @@ #include "ForceAccumulatorSystem.h" - namespace Reality { ForceAccumulatorSystem::ForceAccumulatorSystem() { requireComponent(); + requireComponent(); } - void ForceAccumulatorSystem::Update(float deltaTime) { for (auto e : getEntities()) { - auto &particle = e.getComponent(); - particle.accelaration = particle.GetForce() * particle.inverseMass; - particle.ResetForceAccumulator(); + auto& particle = e.getComponent(); + auto& forceAcc = e.getComponent(); + + particle.acceleration = forceAcc.GetAccumulatedForce() * forceAcc.inverseMass; + forceAcc.ResetAccumulator(); } } } diff --git a/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.h b/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.h index ff375ad..ce612ed 100644 --- a/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.h +++ b/OpenGLEngine/OpenGLEngine/ForceAccumulatorSystem.h @@ -1,6 +1,7 @@ #pragma once #include "ECSConfig.h" #include "ParticleComponent.h" +#include "ForceAccumulatorComponent.h" namespace Reality { @@ -11,4 +12,3 @@ namespace Reality void Update(float deltaTime); }; } - diff --git a/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorComponent.h b/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorComponent.h new file mode 100644 index 0000000..7d9f67b --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorComponent.h @@ -0,0 +1,58 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct ForceAndTorqueAccumulatorComponent + { + ForceAndTorqueAccumulatorComponent(float _mass = 1.0f, float _inertia = 1.0f) + : inverseMass(1.0f / _mass), forceAccumulator(Vector3(0, 0, 0)), + inertiaTensor(Mat3(_inertia)), torqueAccumulator(Vector3(0, 0, 0)) + { + + } + float inverseMass; + Mat3 inertiaTensor; + + inline void AddForce(const Vector3& force) + { + forceAccumulator += force; + } + inline void ResetForceAccumulator() + { + forceAccumulator = Vector3(0, 0, 0); + } + inline const Vector3& GetAccumulatedForce() + { + return forceAccumulator; + } + + inline void AddTorque(const Vector3& torque) + { + torqueAccumulator += torque; + } + inline void ResetTorqueAccumulator() + { + torqueAccumulator = Vector3(0, 0, 0); + } + inline const Vector3& GetAccumulatedTorque() + { + return torqueAccumulator; + } + + inline void AddForceAtPoint(const Vector3& force, const Vector3& point, const Vector3& origin) + { + AddForce(force); + AddTorque(glm::cross(point - origin, force)); + } + + inline const Mat3& GetWorldInverseInertiaTensor(const Mat3& localToWorldRotation) + { + return localToWorldRotation * inertiaTensor * glm::inverse(localToWorldRotation); + } + + private: + Vector3 forceAccumulator; + Vector3 torqueAccumulator; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.cpp b/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.cpp index 3b91bdb..8f1cf94 100644 --- a/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.cpp @@ -5,23 +5,24 @@ namespace Reality ForceAndTorqueAccumulatorSystem::ForceAndTorqueAccumulatorSystem() { requireComponent(); - requireComponent(); + requireComponent(); + requireComponent(); } void ForceAndTorqueAccumulatorSystem::Update(float deltaTime) { for (auto e : getEntities()) { - auto &rigidbody = e.getComponent(); - auto &transform = e.getComponent(); + auto& transform = e.getComponent(); + auto& rigidbody = e.getComponent(); + auto& forceAndTorqueAcc = e.getComponent(); - rigidbody.accelaration = rigidbody.GetForce() * rigidbody.inverseMass; - rigidbody.ResetForceAccumulator(); + rigidbody.acceleration = forceAndTorqueAcc.GetAccumulatedForce() * forceAndTorqueAcc.inverseMass; + forceAndTorqueAcc.ResetForceAccumulator(); - Mat3 rotMat = transform.GetRotationMatrix(); - rigidbody.angularAccelaration = rigidbody.worldInverseInertiaTensor(rotMat) - * rigidbody.GetTorque(); - rigidbody.ResetTorqueAccumulator(); + Mat3 worldInvInertia = forceAndTorqueAcc.GetWorldInverseInertiaTensor(transform.GetRotationMatrix()); + rigidbody.angularAcceleration = worldInvInertia * forceAndTorqueAcc.GetAccumulatedTorque(); + forceAndTorqueAcc.ResetTorqueAccumulator(); } } } diff --git a/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.h b/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.h index d4f0221..cea9f11 100644 --- a/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.h +++ b/OpenGLEngine/OpenGLEngine/ForceAndTorqueAccumulatorSystem.h @@ -1,6 +1,7 @@ #pragma once #include "ECSConfig.h" -#include "RigidBodyComponent.h" +#include "RigidbodyComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" #include "TransformComponentV2.h" namespace Reality diff --git a/OpenGLEngine/OpenGLEngine/GravityForceComponent.h b/OpenGLEngine/OpenGLEngine/GravityForceComponent.h new file mode 100644 index 0000000..19be3c5 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/GravityForceComponent.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct GravityForceComponent + { + GravityForceComponent(float _gravityScale = 10.0f) + : gravityScale(_gravityScale) + { + + } + float gravityScale; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/GravityForceSystem.cpp b/OpenGLEngine/OpenGLEngine/GravityForceSystem.cpp new file mode 100644 index 0000000..142c144 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/GravityForceSystem.cpp @@ -0,0 +1,24 @@ +#include "GravityForceSystem.h" + +namespace Reality +{ + GravityForceSystem::GravityForceSystem() + { + requireComponent(); + requireComponent(); + } + + void GravityForceSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& forceAcc = e.getComponent(); + auto& gravity = e.getComponent(); + + if (forceAcc.inverseMass > 0) + { + forceAcc.AddForce(worldGravity * gravity.gravityScale / forceAcc.inverseMass); + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/GravityForceSystem.h b/OpenGLEngine/OpenGLEngine/GravityForceSystem.h new file mode 100644 index 0000000..1d75b37 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/GravityForceSystem.h @@ -0,0 +1,16 @@ +#pragma once +#include "ECSConfig.h" +#include "ForceAccumulatorComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" +#include "GravityForceComponent.h" + +namespace Reality +{ + class GravityForceSystem : public ECSSystem + { + public: + GravityForceSystem(); + void Update(float deltaTime); + Vector3 worldGravity = Vector3(0.0f, -9.8f, 0.0f); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/LifeTimeComponent.h b/OpenGLEngine/OpenGLEngine/LifeTimeComponent.h index 0173690..94ed8c2 100644 --- a/OpenGLEngine/OpenGLEngine/LifeTimeComponent.h +++ b/OpenGLEngine/OpenGLEngine/LifeTimeComponent.h @@ -5,14 +5,13 @@ namespace Reality { struct LifeTimeComponent { - LifeTimeComponent(float _maxTime = 10) - :maxTime(_maxTime), timer(0), startSize(RANDOM_FLOAT(1.0f, 3.0f)), size(0) + LifeTimeComponent(float _maxTime = 5, Color _color = Color::Green) + :maxTime(_maxTime), timer(0), color(_color) { } float maxTime; float timer; - float startSize; - float size; + Color color; }; } diff --git a/OpenGLEngine/OpenGLEngine/LifeTimeSystem.cpp b/OpenGLEngine/OpenGLEngine/LifeTimeSystem.cpp index b188084..afe6b1a 100644 --- a/OpenGLEngine/OpenGLEngine/LifeTimeSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/LifeTimeSystem.cpp @@ -4,21 +4,21 @@ namespace Reality { LifeTimeSystem::LifeTimeSystem() { - requireComponent(); requireComponent(); + requireComponent(); } void LifeTimeSystem::Update(float deltaTime) { for (auto e : getEntities()) { - auto& life = e.getComponent(); auto& transform = e.getComponent(); + auto& lifeTime = e.getComponent(); + + getWorld().data.renderUtil->DrawSphere(transform.GetPosition(), 1.0f, lifeTime.color); - life.timer += deltaTime; - life.size = life.startSize + 10.0f * pow(life.timer, 0.5f); - getWorld().data.renderUtil->DrawSphere(transform.GetPosition(), life.size, Color::Yellow); - if (life.timer > life.maxTime) + lifeTime.timer += deltaTime; + if (lifeTime.timer >= lifeTime.maxTime) { e.kill(); } diff --git a/OpenGLEngine/OpenGLEngine/LifeTimeSystem.h b/OpenGLEngine/OpenGLEngine/LifeTimeSystem.h index 17b76fb..db8725c 100644 --- a/OpenGLEngine/OpenGLEngine/LifeTimeSystem.h +++ b/OpenGLEngine/OpenGLEngine/LifeTimeSystem.h @@ -1,7 +1,7 @@ #pragma once #include "ECSConfig.h" -#include "LifeTimeComponent.h" #include "TransformComponentV2.h" +#include "LifeTimeComponent.h" namespace Reality { diff --git a/OpenGLEngine/OpenGLEngine/Main.cpp b/OpenGLEngine/OpenGLEngine/Main.cpp index 91a5161..f1ae7ca 100644 --- a/OpenGLEngine/OpenGLEngine/Main.cpp +++ b/OpenGLEngine/OpenGLEngine/Main.cpp @@ -1,59 +1,55 @@ //#define STB_IMAGE_IMPLEMENTATION -#include "UpdateTransformMatricesSystem.h" #include "RenderingSystem.h" #include "RenderingSystemV2.h" #include "InputEventSystem.h" +#include "FPSControlSystem.h" +#include "FollowCameraSystem.h" #include "RotateSystem.h" -#include "ParticleSystem.h" -#include "ParticleSpawnerSystem.h" -#include "GravityForceGeneratorSystem.h" -#include "FixedSpringForceGeneratorSystem.h" -#include "ForceAccumulatorSystem.h" -#include "PairedSpringForceGeneratorSystem.h" -#include "SphereContactGeneratorSystem.h" -#include "ParticleContactResolutionSystem.h" -#include "CableComponentSystem.h" +#include "RotateSystemV2.h" +#include "LifeTimeSystem.h" +#include "FireworksSystem.h" +#include "GravityForceSystem.h" +#include "DragForceSystem.h" +#include "FixedSpringSystem.h" +#include "PairedSpringSystem.h" +#include "ParticleSphereSystem.h" +#include "CableSystem.h" #include "RodSystem.h" +#include "ParticleContactResolutionSystem.h" +#include "ResetPenetrationDeltaMoveSystem.h" +#include "ForceAccumulatorSystem.h" +#include "BuoyancySystem.h" +#include "ParticleSystem.h" +#include "RigidbodySystem.h" #include "ForceAndTorqueAccumulatorSystem.h" -#include "RigidBodySystem.h" -#include "RigidbodyGravityForceGeneratorSystem.h" -#include "ContactGenerationSystem.h" -#include "ContactResolutionSystem.h" -#include "SphereColliderSystem.h" -#include "BoxColliderSystem.h" -#include "MoveInBoundsSystem.h" -#include "FPSControlSystem.h" +#include "DragSystem.h" +#include "AddTorqueFromCameraSystem.h" +#include "AeroControlSystem.h" +#include "AeroSurfaceSystem.h" +#include "ThrusterSystem.h" #include "DynamicDirectionalLightSystem.h" #include "DynamicPointLightSystem.h" #include "DynamicSpotLightSystem.h" -#include "FlightSimulatorSystem.h" -#include "FollowCameraSystem.h" -#include "InfiniteSpawnSystem.h" -#include "InfiniteSpawnTargetSystem.h" -#include "AeroControlSystem.h" -#include "SetAerodynamicTensorSystem.h" -#include "AeroSystem.h" -#include "CameraLookSystem.h" -#include "LifeTimeSystem.h" #include #include #include -#define DEBUG_LOG_LEVEL 3 - using namespace Reality; void LoadShaders(ECSWorld& world); void LoadModels(ECSWorld& world); +void SetupLights(ECSWorld& world); void MakeABunchaObjects(ECSWorld& world); +void MakeFireworks(ECSWorld& world); +void Make3Particles(ECSWorld& world); void MakeABunchaSprings(ECSWorld& world); void MakeABunchaSpheres(ECSWorld& world); -void MakeACable(ECSWorld& world); -void MakeCablesAndRods(ECSWorld& world); -void MakeFlight(ECSWorld& world); -void TestContacts(ECSWorld& world); -void TestCollision(ECSWorld& world); -void SetupLights(ECSWorld& world); +void MakeABunchaCablesAndRods(ECSWorld& world); +void MakeARopeBridge(ECSWorld& world); +void MakeABunchaObjectsV2(ECSWorld& world); +void MakeRigidBodyTest(ECSWorld& world); +void MakeAFlightSimulator(ECSWorld& world); +void MakeABoat(ECSWorld& world); int main() { @@ -63,7 +59,7 @@ int main() world.data.InitRendering(); //LoadAssets(world); - world.data.renderUtil->camera.Position = Vector3(0, 15.0f, 100.0f); + world.data.renderUtil->camera.Position = Vector3(0, 0.0f, 50.0f); world.data.renderUtil->SetFOV(60); // Create entities @@ -71,63 +67,52 @@ int main() auto e = world.createEntity(); e.addComponent(); - //auto wall = world.createEntity(); - //wall.addComponent(Vector3(0, -3.0f, 0.0f), Vector3(0.1f, 0.1f, 0.1f), Vector3(0, 270, 0)); - //// Add mesh - //wall.addComponent("Resources/Models/Sponza-master/sponza.obj"); - SetupLights(world); //MakeABunchaObjects(world); - //MakeABunchaSpheres(world); + //MakeFireworks(world); + //Make3Particles(world); //MakeABunchaSprings(world); - //MakeACable(world); - //akeCablesAndRods(world); - //MakeFlight(world); - //TestContacts(world); - TestCollision(world); + //MakeABunchaSpheres(world); + //MakeABunchaCablesAndRods(world); + //MakeARopeBridge(world); + //MakeABunchaObjectsV2(world); + //MakeRigidBodyTest(world); + //MakeAFlightSimulator(world); + MakeABoat(world); // Create Systems - world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); - world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); world.getSystemManager().addSystem(); - // Rigidbody Physics - rp3d::CollisionWorld rp3dWorld; - world.getSystemManager().addSystem(rp3dWorld); - world.getSystemManager().addSystem(rp3dWorld); - world.getSystemManager().addSystem(rp3dWorld); - world.getSystemManager().addSystem(rp3dWorld); - world.getSystemManager().addSystem(rp3dWorld); - world.getSystemManager().addSystem(); - - float time = glfwGetTime(); float stepTime = glfwGetTime(); float deltaTime = 0; @@ -171,49 +156,55 @@ int main() // Game Logic Update world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - - //Flight Sim - world.getSystemManager().getSystem().Update(deltaTime); world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); - world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); + world.getSystemManager().getSystem().Update(deltaTime); // Update Transform - world.getSystemManager().getSystem().Update(deltaTime); + // Physics - float fixedDeltaTime = glfwGetKey(world.data.renderUtil->window->glfwWindow, GLFW_KEY_SPACE) == GLFW_PRESS ? 1 / 60.0f : 0; - //float fixedDeltaTime = 1 / 60.0f; - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - // Particle Force Generators - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); + //float fixedDeltaTime = glfwGetKey(world.data.renderUtil->window->glfwWindow, GLFW_KEY_SPACE) == GLFW_PRESS ? 1 / 60.0f : 0; + float fixedDeltaTime = 1 / 60.0f; + // Force Generator + /// Particle + world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); + /// Rigidbody + world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); + + // Force Accumulator + /// Particle world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - // Rigiidbody Force Generators and collisions - world.getSystemManager().getSystem().Update(fixedDeltaTime); + /// Rigidbody world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - // Physics Solvers - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); + + // Contact Resolution world.getSystemManager().getSystem().Update(fixedDeltaTime); + world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); - world.getSystemManager().getSystem().Update(fixedDeltaTime); + // Integrator + /// Particle + world.getSystemManager().getSystem().Update(fixedDeltaTime); + /// Rigidbody + world.getSystemManager().getSystem().Update(fixedDeltaTime); // Rendering Update + ///*** HACK: For the last DrawCall not working on some systems + world.data.renderUtil->DrawCube(Vector3(0, 0, 0), Vector3(0, 0, 0)); + ///*** HACK: For the last DrawCall not working on some systems world.getSystemManager().getSystem().Update(deltaTime); world.getSystemManager().getSystem().Update(deltaTime); world.getSystemManager().getSystem().Update(deltaTime); @@ -276,365 +267,478 @@ void LoadShaders(ECSWorld& world) void LoadModels(ECSWorld& world) { world.data.assetLoader->StartModelLoading({ - //ModelData("Resources/Models/snowy-mountain-terrain/SnowyMountainMesh.obj"), - //ModelData("Resources/Models/Sponza-master/sponza.obj"), - //ModelData("Resources/Models/nanosuit/nanosuit.obj"),*/ - ModelData("Resources/Models/supermarine-spitfire/spitfire.fbx", - {{"spitfire_d.png"}}) + ModelData("Resources/Models/Sponza-master/sponza.obj"), + ModelData("Resources/Models/nanosuit/nanosuit.obj"), + ModelData("Resources/Models/Sponza-master/sponza.obj"), + {{"spitfire_d.png"}}, + ModelData("Resources/Models/boat/Vagabond.obj", + {{"wood-textures-high-quality-1.png"}}) }); } void MakeABunchaObjects(ECSWorld& world) { - auto e = world.createEntity(); - e.addComponent(Vector3(4, 10.0f, 48), Vector3(0.10f, 0.1f, 0.1f), Vector3(-90, 180, 0)); + auto castle = world.createEntity(); + castle.addComponent(Vector3(0, -3.0f, 0.0f), Vector3(0.1f, 0.1f, 0.1f), Vector3(0, 270, 0)); // Add mesh - e.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx"); - e.addComponent(0, 40, 0); + castle.addComponent("Resources/Models/Sponza-master/sponza.obj"); + + //auto flight = world.createEntity(); + //flight.addComponent(Vector3(0, 30, -50), Vector3(0.1f, 0.1f, 0.1f), Vector3(270, 0, 0)); + //// Add mesh + //flight.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx"); + //flight.addComponent(Vector3(0, 90, 0)); + //flight.addComponent(Vector3(0, 30, 0)); + //flight.addComponent(); + //flight.addComponent(); - e = world.createEntity(); - e.addComponent(Vector3(4, 10.0f, -62), Vector3(0.1f, 0.1f, 0.1f), Vector3(-90, 0, 0)); - // Add mesh - e.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx"); - e.addComponent(0, 40, 0); } -void MakeABunchaSprings(ECSWorld& world) +void MakeFireworks(ECSWorld & world) { - auto e = world.createEntity(); - float yOffset = 30; - e.addComponent(Vector3(-2.5f, -5 + yOffset, -3), Vector3(1.0f, 1.0f, 1.0f)); - e.addComponent(); - // Add mesh - e.addComponent("Resources/Models/nanosuit/nanosuit.obj"); - - auto springEntinty = world.createEntity(); - springEntinty.addComponent(Vector3(-2.5f, 0 + yOffset, 3)); - springEntinty.addComponent(8, 2, e); + for (int i = 0; i < 3; i++) + { + auto fireworks = world.createEntity(); + fireworks.addComponent(Vector3(-100 + 100 * i, 30 + RANDOM_FLOAT(-10, 10), -50)); + fireworks.addComponent(Vector3(0, 100, 0)); + fireworks.addComponent(); + fireworks.addComponent(); + fireworks.addComponent(6, 3, 3 + RANDOM_FLOAT(-1, 1)); + } + +} - auto e2 = world.createEntity(); - e2.addComponent(Vector3(2.5f, -5 + yOffset, -1), Vector3(1.0f, 1.0f, 1.0f)); - e2.addComponent(); - // Add mesh - e2.addComponent("Resources/Models/nanosuit/nanosuit.obj"); +void Make3Particles(ECSWorld & world) +{ + auto particle1 = world.createEntity(); + particle1.addComponent(Vector3(-10, 60, -50)); + particle1.addComponent(Vector3(0, 0, 0)); + particle1.addComponent(); + particle1.addComponent(); + particle1.addComponent(0, 0); + + auto particle2 = world.createEntity(); + particle2.addComponent(Vector3(0, 60, -50)); + particle2.addComponent(Vector3(0, 0, 0)); + particle2.addComponent(); + particle2.addComponent(); + particle2.addComponent(1, 0); + + auto particle3 = world.createEntity(); + particle3.addComponent(Vector3(10, 60, -50)); + particle3.addComponent(Vector3(0, 0, 0)); + particle3.addComponent(); + particle3.addComponent(); + particle3.addComponent(1, 1); +} - auto springEntinty2 = world.createEntity(); - springEntinty2.addComponent(Vector3(2.5f, 0 + yOffset, 1)); - springEntinty2.addComponent(5, 5, e2); +void MakeABunchaSprings(ECSWorld & world) +{ + auto particle1 = world.createEntity(); + particle1.addComponent(Vector3(0, 20, -50)); + particle1.addComponent(Vector3(0, 0, 0)); + particle1.addComponent(); + particle1.addComponent(); + + auto particle2= world.createEntity(); + particle2.addComponent(Vector3(-10, 0, -50)); + particle2.addComponent(Vector3(0, 0, 0)); + particle2.addComponent(); + particle2.addComponent(); + + auto spring1 = world.createEntity(); + spring1.addComponent(Vector3(10, 60, -50)); + spring1.addComponent(20.0f, 20.0f, particle1); + + auto spring2 = world.createEntity(); + spring2.addComponent(Vector3(-10, 60, -50)); + spring2.addComponent(20.0f, 15.0f, particle1); auto pairedSpring = world.createEntity(); - pairedSpring.addComponent(100, 5.0f, e, e2); - - auto e3 = world.createEntity(); - e3.addComponent(Vector3(-7.5f, -7.5f + yOffset, 1), Vector3(1.0f, 1.0f, 1.0f)); - e3.addComponent(); - // Add mesh - e3.addComponent("Resources/Models/nanosuit/nanosuit.obj"); - - auto springEntinty3 = world.createEntity(); - springEntinty3.addComponent(Vector3(-7.5f, -10 + yOffset, -1)); - springEntinty3.addComponent(7, 7, e3); - - auto e4 = world.createEntity(); - e4.addComponent(Vector3(7.5f, -7.5f + yOffset, 3), Vector3(1.0f, 1.0f, 1.0f)); - e4.addComponent(); - // Add mesh - e4.addComponent("Resources/Models/nanosuit/nanosuit.obj"); + pairedSpring.addComponent(20.0f, 20.0f, particle1, particle2); - auto springEntinty4 = world.createEntity(); - springEntinty4.addComponent(Vector3(7.5f, -10 + yOffset, -3)); - springEntinty4.addComponent(5, 0, e4); - - auto pairedSpring2 = world.createEntity(); - pairedSpring2.addComponent(100, 5.2f, e, e3); - - auto pairedSpring3 = world.createEntity(); - pairedSpring3.addComponent(100, 5.2f, e2, e4); - - auto pairedSpring4 = world.createEntity(); - pairedSpring4.addComponent(100, 10.0f, e3, e4); } -void MakeABunchaSpheres(ECSWorld& world) +void MakeABunchaSpheres(ECSWorld & world) { - for (int i = 0; i < 30; i++) + for (int i = 0; i < 40; i++) { - auto e = world.createEntity(); - //e.addComponent(Vector3(RANDOM_FLOAT(-1, 1), 20,0)); - - e.addComponent(Vector3(RANDOM_FLOAT(-15.0f, 15.0f), RANDOM_FLOAT(6.0f, 34.0f), RANDOM_FLOAT(-15.0f, 15.0f))); - e.addComponent(1, Vector3(RANDOM_FLOAT(-5, 5), RANDOM_FLOAT(-5, 5), RANDOM_FLOAT(-5, 5))); - e.addComponent(1); - Color col = Color(0, RANDOM_FLOAT(0.0f, 1.0f), RANDOM_FLOAT(0.0f, 1.0f)); - //e.addComponent(20.0f, col, col, col); + auto sphere = world.createEntity(); + sphere.addComponent(Vector3(RANDOM_FLOAT(-10, 10), RANDOM_FLOAT(-10, 10), RANDOM_FLOAT(-10, 10))); + sphere.addComponent(Vector3(RANDOM_FLOAT(-40, 40), RANDOM_FLOAT(-40, 40), RANDOM_FLOAT(-40, 40))); + sphere.addComponent(1.0f); + sphere.addComponent(); + sphere.addComponent(RANDOM_FLOAT(1, 3)); } +} - auto ref = world.createEntity(); - ref.addComponent(Vector3(0, 20, 0), Vector3(0.3f, 0.3f, 0.3f), Vector3(0, 180, 0)); - // Add mesh - ref.addComponent("Resources/Models/nanosuit/nanosuit.obj"); - ref.addComponent(0, 40, 0); +void CreateParticleArchetype(ECSEntity e) +{ + e.addComponent(); + e.addComponent(); + e.addComponent(); + //e.addComponent(); + e.addComponent(); } -void MakeACable(ECSWorld& world) +void MakeARopeBridge(ECSWorld & world) { + auto ePivot1 = world.createEntity(); + ePivot1.addComponent(Vector3(3, 10, 5)); + auto e1 = world.createEntity(); - e1.addComponent(Vector3(0, 40, 0)); - //e1.addComponent(1, Vector3(0,0,0), 0); + e1.addComponent(Vector3(0, 3, 5)); + CreateParticleArchetype(e1); + + auto ePivot2 = world.createEntity(); + ePivot2.addComponent(Vector3(3, 10, -5)); auto e2 = world.createEntity(); - e2.addComponent(Vector3(0, 30, 0)); - e2.addComponent(1); - - auto e = world.createEntity(); - e.addComponent(e1, e2, 20); -} + e2.addComponent(Vector3(0, 2, -5)); + CreateParticleArchetype(e2); -void MakeCablesAndRods(ECSWorld& world) -{ - auto eFixed = world.createEntity(); - eFixed.addComponent(Vector3(10, 40, 0)); - //e1.addComponent(1, Vector3(0,0,0), 0); + auto rod1 = world.createEntity(); + rod1.addComponent(e1, e2, 10); - auto eFixed2 = world.createEntity(); - eFixed2.addComponent(Vector3(20, 10, 0)); + auto cable1 = world.createEntity(); + cable1.addComponent(ePivot1, e1, 20, 1); - auto eFixed3 = world.createEntity(); - eFixed3.addComponent(Vector3(-20, 10, 0)); + auto cable2 = world.createEntity(); + cable2.addComponent(ePivot2, e2, 20, 1); - auto e1 = world.createEntity(); - e1.addComponent(Vector3(0, 30, 0)); - e1.addComponent(10); - - auto e2 = world.createEntity(); - e2.addComponent(Vector3(-10, 20, 0)); - e2.addComponent(10); + // 2 + auto ePivot3 = world.createEntity(); + ePivot3.addComponent(Vector3(3 + 10, 10, 5)); auto e3 = world.createEntity(); - e3.addComponent(Vector3(0, 10, 0)); - e3.addComponent(10); + e3.addComponent(Vector3(0 + 10, -2, 5)); + CreateParticleArchetype(e3); + + auto ePivot4 = world.createEntity(); + ePivot4.addComponent(Vector3(3 + 10, 10, -5)); auto e4 = world.createEntity(); - e4.addComponent(Vector3(10, 20, 0)); - e4.addComponent(10); - - auto eCable = world.createEntity(); - eCable.addComponent(eFixed, e1, 20); - - auto eCable2 = world.createEntity(); - eCable2.addComponent(1000, 20, eFixed2, e4); - - auto eCable3 = world.createEntity(); - eCable3.addComponent(1000, 20, eFixed3, e2); - - auto eRod1 = world.createEntity(); - eRod1.addComponent(e1, e2, 10 * sqrt(2)); - auto eRod2 = world.createEntity(); - eRod2.addComponent(e2, e3, 10 * sqrt(2)); - auto eRod3 = world.createEntity(); - eRod3.addComponent(e3, e4, 10 * sqrt(2)); - auto eRod4 = world.createEntity(); - eRod4.addComponent(e4, e1, 10 * sqrt(2)); - - auto eRodDiagonal1 = world.createEntity(); - eRodDiagonal1.addComponent(e1, e3, 20); - auto eRodDiagonal2 = world.createEntity(); - eRodDiagonal2.addComponent(e2, e4, 20); + e4.addComponent(Vector3(0 + 10, 0, -5)); + CreateParticleArchetype(e4); + + auto rod2 = world.createEntity(); + rod2.addComponent(e3, e4, 10); + + auto cable3 = world.createEntity(); + cable3.addComponent(ePivot3, e3, 15, 1); + + auto cable4 = world.createEntity(); + cable4.addComponent(ePivot4, e4, 15, 1); + + // 3 + auto ePivot5 = world.createEntity(); + ePivot5.addComponent(Vector3(3 - 10, 10, 5)); + + auto e5 = world.createEntity(); + e5.addComponent(Vector3(0 - 10, 1, 5)); + CreateParticleArchetype(e5); + + auto ePivot6 = world.createEntity(); + ePivot6.addComponent(Vector3(3 - 10, 10, -5)); + + auto e6 = world.createEntity(); + e6.addComponent(Vector3(0 - 10, -1, -5)); + CreateParticleArchetype(e6); + + auto rod3 = world.createEntity(); + rod3.addComponent(e5, e6, 10); + + auto cable5 = world.createEntity(); + cable5.addComponent(ePivot5, e5, 15, 1); + + auto cable6 = world.createEntity(); + cable6.addComponent(ePivot6, e6, 15, 1); + + // rods + auto rod4 = world.createEntity(); + rod4.addComponent(e1, e3, 10); + auto rod5 = world.createEntity(); + rod5.addComponent(e2, e4, 10); + auto rod6 = world.createEntity(); + rod6.addComponent(e5, e1, 10); + auto rod7 = world.createEntity(); + rod7.addComponent(e6, e2, 10); + + // diagonal rods + auto rod8 = world.createEntity(); + rod8.addComponent(e1, e4, 10 * pow(2.0f, 0.5f)); + auto rod9 = world.createEntity(); + rod9.addComponent(e2, e3, 10 * pow(2.0f, 0.5f)); + auto rod10 = world.createEntity(); + rod10.addComponent(e6, e1, 10 * pow(2.0f, 0.5f)); + auto rod11 = world.createEntity(); + rod11.addComponent(e5, e2, 10 * pow(2.0f, 0.5f)); } -void MakeFlight(ECSWorld& world) +void MakeABunchaObjectsV2(ECSWorld & world) { - auto e = world.createEntity(); - glm::vec3 rotationInRads = glm::vec3(glm::radians(-90.0f), - glm::radians(180.0f), glm::radians(0.0f)); - Quaternion orientation = glm::quat(rotationInRads); - e.addComponent(Vector3(0, 350.0f, 0), Vector3(0.10f, 0.1f, 0.1f)); + auto flightV1 = world.createEntity(); + flightV1.addComponent(Vector3(-50, 0, -50), Vector3(0.1f, 0.1f, 0.1f), Vector3(270, 0, 0)); // Add mesh - e.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx", Vector3(0, -50, 20), Vector3(-90, 0, 0)); - e.addComponent(10.0f ,0.3f, 0.5f); - e.addComponent(); - e.addComponent(Vector3(0.0f, 15.0f, 40.0f)); - e.addComponent(); - e.addComponent(); - - std::vector p1 { GLFW_KEY_E }; - std::vector n1 { GLFW_KEY_Q }; - //Right Wing - auto RW = world.createEntity(); - RW.addComponent(p1, n1); - RW.addComponent(Mat3(0, 0, 0, 0, 0.000f, 0, 0, -0.0005f, 0), - Mat3(0, 0, 0, 0, 0, 0, 0, 0, 0), - Mat3(0, 0, 0, 0, -0.000f, 0, 0, 0.0005f, 0)); - RW.addComponent(e, Mat3(1.0f), Vector3(100.0f, 0, 50.0f)); - - //Left Wing - auto LW = world.createEntity(); - LW.addComponent(n1, p1); - LW.addComponent(Mat3(0, 0, 0, 0, 0.000f, 0, 0, -0.0005f, 0), - Mat3(0, 0, 0, 0, 0, 0, 0, 0, 0), - Mat3(0, 0, 0, 0, -0.000f, 0, 0, 0.0005f, 0)); - LW.addComponent(e, Mat3(1.0f), Vector3(-100.0f, 0, 50.0f)); - - //Rudder - std::vector pR = { GLFW_KEY_A }; - std::vector nR = { GLFW_KEY_D }; - auto R = world.createEntity(); - R.addComponent(pR, nR); - R.addComponent(Mat3(0, 0, 0, 0, 0, 0, 0.002f, 0, 0), - Mat3(0, 0, 0, 0, 0, 0, 0.00f, 0, 0), - Mat3(0, 0, 0, 0, 0, 0, -0.002f, 0, 0)); - R.addComponent(e, Mat3(1.0f), Vector3(0, 0, -200.0f)); - - //Back Wing - std::vector p2{ GLFW_KEY_W }; - std::vector n2{ GLFW_KEY_S }; - auto RW2 = world.createEntity(); - RW2.addComponent(p2, n2); - RW2.addComponent(Mat3(0, 0, 0, 0, 0, 0, 0, -0.0015f, 0), - Mat3(0, 0, 0, 0, 0, 0, 0, 0, 0), - Mat3(0, 0, 0, 0, 0, 0, 0, 0.0015f, 0)); - RW2.addComponent(e, Mat3(1.0f), Vector3(0.0f, 0, -200.0f)); - - for (int i = -40; i <= 40; i++) - { - auto buildingR = world.createEntity(); - buildingR.addComponent(Vector3(100.0f, 0.0f, 50.0f * i)); - buildingR.addComponent(RANDOM_FLOAT(100.0f, 500.0f)); + flightV1.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx"); + flightV1.addComponent(Vector3(45, 70, -20)); - auto buildingL = world.createEntity(); - buildingL.addComponent(Vector3(-100.0f, 0.0f, 50.0f * i)); - buildingL.addComponent(RANDOM_FLOAT(100.0f, 500.0f)); - } + auto flightV2 = world.createEntity(); + flightV2.addComponent(Vector3(50, 0, -50), Vector3(0.1f, 0.1f, 0.1f), Vector3(270, 0, 0)); + // Add mesh + flightV2.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx"); + flightV2.addComponent(Vector3(45, 70, -20)); } -void TestContacts(ECSWorld& world) +void MakeRigidBodyTest(ECSWorld & world) { - for (int i = 0; i < 30; i++) - { - auto e = world.createEntity(); - e.addComponent(Vector3(RANDOM_FLOAT(-200.0f, 200.0f), RANDOM_FLOAT(-200.0f, 200.0f), RANDOM_FLOAT(-200.0f, 200.0f)), - Vector3(1, 1, 1), - Vector3(RANDOM_FLOAT(-180.0f, 180.0f), RANDOM_FLOAT(-180.0f, 180.0f), RANDOM_FLOAT(-180.0f, 180.0f))); - e.addComponent(); - e.addComponent(Vector3(RANDOM_FLOAT(-10.0f, 10.0f), RANDOM_FLOAT(-10.0f, 10.0f), RANDOM_FLOAT(-10.0f, 10.0f)), - Vector3(200, 200, 200)); - auto col = world.createEntity(); - if ((RANDOM_FLOAT(0.0f, 1.0f) >= 0.5f)) - { - col.addComponent(e, RANDOM_FLOAT(10.0f, 50.0f)); - } - else - { - col.addComponent(e, Vector3(RANDOM_FLOAT(30.0f, 70.0f), RANDOM_FLOAT(30.0f, 70.0f), RANDOM_FLOAT(30.0f, 70.0f))); - } - } - /*for (int i = 0; i < 2; i++) - { - auto e = world.createEntity(); - e.addComponent(Vector3(50 * ( i % 2 == 0 ? -1 : 1), 0, 0)); - e.addComponent(); - e.addComponent(Vector3(10 * (i % 2 == 0 ? 1 : -1), 0, 0), Vector3(100, 100, 100)); - auto col = world.createEntity(); - col.addComponent(e, 30); - }*/ + auto flight = world.createEntity(); + flight.addComponent(Vector3(0, 0, -50), Vector3(0.1f, 0.1f, 0.1f)); + flight.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx", Vector3(-90, 0, 0), Vector3(0, -50, 0)); + flight.addComponent(); + flight.addComponent(); + flight.addComponent(); + flight.addComponent(); } -void TestCollision(ECSWorld& world) +void MakeAFlightSimulator(ECSWorld & world) { - // Floor 1 - auto floor1 = world.createEntity(); - floor1.addComponent(Vector3(0, -50, 0), Vector3(1, 1, 1), Vector3(0, 0, 0)); - floor1.addComponent(100000.0f, 0.4f, 0.3f, Vector3(0, 0, 0), Vector3(0, 0, 0), 0); - auto floorCol1 = world.createEntity(); - floorCol1.addComponent(floor1, Vector3(1000, 10, 1000)); - - // Floor 2 - /*auto floor2 = world.createEntity(); - floor2.addComponent(Vector3(80, -50, 0), Vector3(1, 1, 1), Vector3(0, 0, 30)); - floor2.addComponent(10000.0f, 0.0f, 0.0f, Vector3(0, 0, 0), Vector3(0, 0, 0), 0); - auto floorCol2 = world.createEntity(); - floorCol2.addComponent(floor2, Vector3(300, 10, 300));*/ - - //// Object 1 - //auto object1 = world.createEntity(); - //object1.addComponent(Vector3(-30, 50, 0)); - //object1.addComponent(); - //auto objectCol1 = world.createEntity(); - //objectCol1.addComponent(object1, 10); - - // Object 2 - for (int i = 0; i < 40; i++) - { - auto object2 = world.createEntity(); - object2.addComponent(Vector3(RANDOM_FLOAT(-50.0f, 50.0f), 50, RANDOM_FLOAT(-50.0f, 50.0f)), Vector3(1, 1, 1), Vector3(RANDOM_FLOAT(0, 180), RANDOM_FLOAT(0, 180), RANDOM_FLOAT(0, 180))); - object2.addComponent(10.0f, 0.1f, 0.1f, Vector3(0, 0, 0), Vector3(0, 0, 0), 5); - auto objectCol2 = world.createEntity(); - objectCol2.addComponent(object2, Vector3(10, 10, 10)); - } + auto ground = world.createEntity(); + ground.addComponent(Vector3(0, -1000, 0), Vector3(10, 10, 10), Vector3(0, 90, 0)); + ground.addComponent("Resources/Models/Sponza-master/sponza.obj"); + + auto flight = world.createEntity(); + flight.addComponent(Vector3(0, 0, -50), Vector3(0.1f, 0.1f, 0.1f), Vector3(0, 180, 0)); + flight.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx", Vector3(-90, 0, 0), Vector3(0, -50, 0)); + flight.addComponent(); + flight.addComponent(); + flight.addComponent(0.3, 0.5); + flight.addComponent(); + + auto engine = world.createEntity(); + engine.addComponent(flight); + + auto leftWing = world.createEntity(); + leftWing.addComponent(); + leftWing.addComponent(flight, Vector3(0, 0, 0), Vector3(100, 50, -50)); + std::vector leftWingPositiveKeys = { GLFW_KEY_S, GLFW_KEY_Q }; + std::vector leftWingNegetiveKeys = { GLFW_KEY_W, GLFW_KEY_E }; + leftWing.addComponent( + Vector3(0, 0.1f, 0), + Vector3(0, -0.1f, 0), + leftWingPositiveKeys, leftWingNegetiveKeys); + + auto rightWing = world.createEntity(); + rightWing.addComponent(); + rightWing.addComponent(flight, Vector3(0, 0, 0), Vector3(-100, 50, -50)); + std::vector rightWingPositiveKeys = { GLFW_KEY_S, GLFW_KEY_E }; + std::vector rightWingNegetiveKeys = { GLFW_KEY_W, GLFW_KEY_Q }; + rightWing.addComponent( + Vector3(0, 0.1f, 0), + Vector3(0, -0.1f, 0), + rightWingPositiveKeys, rightWingNegetiveKeys); + + auto rudder = world.createEntity(); + rudder.addComponent(); + rudder.addComponent(flight, Vector3(0, 0, 0), Vector3(0, 0, -150)); + std::vector rudderWingPositiveKeys = { GLFW_KEY_D }; + std::vector rudderWingNegetiveKeys = { GLFW_KEY_A }; + rudder.addComponent( + Vector3(-0.04f, 0, 0), + Vector3(0.04f, 0, 0), + rudderWingPositiveKeys, rudderWingNegetiveKeys); + +} + +void MakeABoat(ECSWorld& world) +{ + std::vector rudderWingPositiveKeys = { GLFW_KEY_D }; + std::vector rudderWingNegetiveKeys = { GLFW_KEY_A }; + + std::vector sailPositiveKeys = { GLFW_KEY_Q }; + std::vector sailNegetiveKeys = { GLFW_KEY_E }; + + auto boat = world.createEntity(); + boat.addComponent(Vector3(0, 120, 0), Vector3(10.0f, 10.0f, 10.0f), Vector3(-5, 0, 0)); + boat.addComponent("Resources/Models/boat/Vagabond.obj", Vector3(0, 0, 0), Vector3(0, 0.2, -1)); + boat.addComponent(); + boat.addComponent(); + boat.addComponent(); + boat.addComponent(0.9, 0.9); + boat.addComponent(); + + auto engine = world.createEntity(); + engine.addComponent(boat); + engine.getComponent().thrust = 50; + + auto sail = world.createEntity(); + sail.addComponent(); + sail.addComponent(boat, Vector3(0, 0, 0), Vector3(5, 3, -0)); + sail.addComponent( + Vector3(0, 0.1f, 0), + Vector3(0, -0.1f, 0), + sailPositiveKeys, sailNegetiveKeys); + + auto rudder = world.createEntity(); + rudder.addComponent(Vector3(0, 0, 0)); + rudder.addComponent(boat, Vector3(0, 0, 0), Vector3(0, 0, -3)); + rudder.addComponent( + Vector3(-0.012f, 0, 0), + Vector3(0.012f, 0, 0), + rudderWingPositiveKeys, rudderWingNegetiveKeys); + + /*auto engine = world.createEntity(); + + engine.addComponent(boat, Vector3(0.0f,0.0f,1.0f), 50.0f);*/ + + auto water = world.createEntity(); + water.addComponent(Vector3(0, 0, 0), Vector3(1, 1, 1)); + water.addComponent(55.0, 100.0f, 25.0f, boat, 0.01f); + + //auto rudder = world.createEntity(); + //rudder.addComponent(); + //rudder.addComponent(boat, Vector3(0,0,0), Vector3(0,0,5)); + //std::vector rudderWingPositiveKeys = { GLFW_KEY_A }; + //std::vector rudderWingNegetiveKeys = { GLFW_KEY_D }; + //rudder.addComponent(Vector3(0,0,0), Vector3(0,0,0), rudderWingPositiveKeys, rudderWingNegetiveKeys); +} + +void MakeABunchaCablesAndRods(ECSWorld & world) +{ + auto ePivot = world.createEntity(); + ePivot.addComponent(Vector3(3, 10, 0)); + + auto e1 = world.createEntity(); + e1.addComponent(Vector3(0, 10, 0)); + e1.addComponent(); + e1.addComponent(); + e1.addComponent(); + e1.addComponent(); + e1.addComponent(); + + auto e2 = world.createEntity(); + e2.addComponent(Vector3(5, 5, 0)); + e2.addComponent(); + e2.addComponent(); + e2.addComponent(); + e2.addComponent(); + e2.addComponent(); + + auto e3 = world.createEntity(); + e3.addComponent(Vector3(0, 0, 0)); + e3.addComponent(); + e3.addComponent(); + e3.addComponent(); + e3.addComponent(); + e3.addComponent(); + + auto e4 = world.createEntity(); + e4.addComponent(Vector3(-5, 5, 0)); + e4.addComponent(); + e4.addComponent(); + e4.addComponent(); + e4.addComponent(); + e4.addComponent(); + + auto cable1 = world.createEntity(); + //cable.addComponent(ePivot, e1, 5, 1); + cable1.addComponent(50, 2, ePivot, e1); + + auto cable2 = world.createEntity(); + //cable.addComponent(ePivot, e1, 5, 1); + cable2.addComponent(50, 25, ePivot, e2); + + auto cable3 = world.createEntity(); + cable3.addComponent(ePivot, e3, 15, 1); + //cable3.addComponent(50, 20, ePivot, e3); + + auto rod1 = world.createEntity(); + rod1.addComponent(e1, e2, 5 * pow(2, 0.5f)); + + auto rod2 = world.createEntity(); + rod2.addComponent(e2, e3, 5 * pow(2, 0.5f)); + + auto rod3 = world.createEntity(); + rod3.addComponent(e3, e4, 5 * pow(2, 0.5f)); + + auto rod4 = world.createEntity(); + rod4.addComponent(e4, e1, 5 * pow(2, 0.5f)); + + auto rod5 = world.createEntity(); + rod5.addComponent(e1, e3, 10); + + auto rod6 = world.createEntity(); + rod6.addComponent(e2, e4, 10); + + //for (int i = 0; i < 20; i++) + //{ + // auto e1 = world.createEntity(); + // e1.addComponent(Vector3(RANDOM_FLOAT(-5, 5), RANDOM_FLOAT(-5, 5), RANDOM_FLOAT(-5, 5))); + // e1.addComponent(); + // e1.addComponent(); + // e1.addComponent(); + // e1.addComponent(RANDOM_FLOAT(0.5, 1.5)); + // e1.addComponent(); + + // auto e2 = world.createEntity(); + // e2.addComponent(Vector3(RANDOM_FLOAT(-5, 5), RANDOM_FLOAT(-5, 5), RANDOM_FLOAT(-5, 5))); + // e2.addComponent(); + // e2.addComponent(); + // e2.addComponent(); + // e2.addComponent(RANDOM_FLOAT(0.5, 1.5)); + // e2.addComponent(); + + // auto rod = world.createEntity(); + // rod.addComponent(e1, e2, RANDOM_FLOAT(6, 10)); + //} } void SetupLights(ECSWorld& world) { auto l = world.createEntity(); l.addComponent(Vector3(0, 0, 0), Vector3(0, 0, 0), Vector3(90, 0, 0)); - l.addComponent(Color(0.00, 0.0, 0), Color::White, Color::Orange); + l.addComponent(Color(1, 1, 1), Color(0.0, 0.1, 0.1), Color(0.0, 0.1, 0.1)); // Lanterns auto pl1 = world.createEntity(); pl1.addComponent(Vector3(22, 14, 48.5f)); pl1.addComponent(100.0f, Color(0.1, 0, 0), Color(1.0f, 0.0f, 0.0f), Color(1.0f, 0.0f, 0.0f)); - pl1.addComponent(); auto hook = world.createEntity(); hook.addComponent(Vector3(23, 15, 48.0f)); - hook.addComponent(5, 1, pl1); hook = world.createEntity(); hook.addComponent(Vector3(22, 13.5f, 50.5f)); - hook.addComponent(5, 1, pl1); hook = world.createEntity(); hook.addComponent(Vector3(21, 12.5f, 47.5f)); - hook.addComponent(5, 1, pl1); auto pl2 = world.createEntity(); pl2.addComponent(Vector3(-14.5f, 14, 49.0f)); pl2.addComponent(100.0f, Color(0, 0, 0.1f), Color(0.0f, 0.0f, 1.0f), Color(0.0f, 0.0f, 1.0f)); - pl2.addComponent(); hook = world.createEntity(); hook.addComponent(Vector3(-14.5f + 1, 14 - 1, 49.0f - 1)); - hook.addComponent(5, 1, pl2); hook = world.createEntity(); hook.addComponent(Vector3(-14.5f - 0.5f, 14 + 1, 49.0f)); - hook.addComponent(5, 1, pl2); hook = world.createEntity(); hook.addComponent(Vector3(-14.5f, 14 - 1, 49.0f + 1)); - hook.addComponent(5, 1, pl2); auto pl3 = world.createEntity(); pl3.addComponent(Vector3(22, 14, -62.0f)); pl3.addComponent(100.0f, Color(0, 0.1f, 0), Color(0.0f, 1.0f, 0.0f), Color(0.0f, 1.0f, 0.0f)); - pl3.addComponent(); hook = world.createEntity(); hook.addComponent(Vector3(22 - 1, 14 - 1, -62.0f)); - hook.addComponent(5, 1, pl3); hook = world.createEntity(); hook.addComponent(Vector3(22, 14 + 0.5f, -62.0f - 1)); - hook.addComponent(5, 1, pl3); hook = world.createEntity(); hook.addComponent(Vector3(22 + 1, 14, -62.0f + 0.5f)); - hook.addComponent(5, 1, pl3); auto pl4 = world.createEntity(); pl4.addComponent(Vector3(-14.5f, 14, -61.5f)); pl4.addComponent(100.0f, Color(0.1, 0.05, 0), Color(1.0f, 0.55f, 0.0f), Color(1.0f, 0.55f, 0.0f)); - pl4.addComponent(); hook = world.createEntity(); hook.addComponent(Vector3(-14.5f - 1, 14, -61.5f -1)); - hook.addComponent(5, 1, pl4); hook = world.createEntity(); hook.addComponent(Vector3(-14.5f - 0.25f, 14 - 0.5f, -61.5f + 1)); - hook.addComponent(5, 1, pl4); hook = world.createEntity(); hook.addComponent(Vector3(-14.5f + 0.5f, 14+ 1, -61.5f + 1)); - hook.addComponent(5, 1, pl4); // Spears std::vector cols = { Color(1,0,0), Color(0,1,0), Color(0,0,1), Color(0.7f,0.55f,0) }; @@ -645,7 +749,6 @@ void SetupLights(ECSWorld& world) pl1 = world.createEntity(); pl1.addComponent(Vector3((i % 2 == 0 ? 8 : -1), 85, 49.5f - 37 * j), Vector3(1, 1, 1), Vector3(180, 0, 0)); pl1.addComponent(10.0f, 100, Color(0, 0, 0), cols[3 - j], cols[3 - j], 5); - pl1.addComponent((i % 2 == 0 ? 1 : -1) * 100,100,100); } } } \ No newline at end of file diff --git a/OpenGLEngine/OpenGLEngine/MeshComponent.h b/OpenGLEngine/OpenGLEngine/MeshComponent.h index f76b4e7..b473b9e 100644 --- a/OpenGLEngine/OpenGLEngine/MeshComponent.h +++ b/OpenGLEngine/OpenGLEngine/MeshComponent.h @@ -11,9 +11,20 @@ namespace Reality Vector3 offset; Vector3 rotation; // Constructor - ModelComponent(std::string const _model = "", Vector3 _offset = Vector3(0, 0, 0), Vector3 _rotation = Vector3(0, 0, 0)) : mesh(_model), offset(_offset), rotation(_rotation) + ModelComponent(std::string const _model = "", Vector3 _rotation = Vector3(0, 0, 0), Vector3 _offset = Vector3(0, 0, 0)) : mesh(_model), offset(_offset), rotation(_rotation) { modelId = -1; + Vector3 rotInRads = Vector3(glm::radians(_rotation.x), glm::radians(_rotation.y), glm::radians(_rotation.z)); + modelOffsetTransformation = Mat4(Quaternion(rotInRads)); + modelOffsetTransformation = glm::translate(Mat4(1.0f), _offset) * modelOffsetTransformation; } + + const Mat4& GetModelOffsetTransformation() + { + return modelOffsetTransformation; + } + + private: + Mat4 modelOffsetTransformation; }; } diff --git a/OpenGLEngine/OpenGLEngine/Mix/System.h b/OpenGLEngine/OpenGLEngine/Mix/System.h index b34947d..b37eafd 100644 --- a/OpenGLEngine/OpenGLEngine/Mix/System.h +++ b/OpenGLEngine/OpenGLEngine/Mix/System.h @@ -125,9 +125,9 @@ void SystemManager::removeSystem() template T& SystemManager::getSystem() { - if (!hasSystem()) { + /* if (!hasSystem()) { throw std::runtime_error(std::string("Failed to get system: ") + typeid(T).name()); - } + }*/ auto it = systems.find(std::type_index(typeid(T))); return *(std::static_pointer_cast(it->second)); diff --git a/OpenGLEngine/OpenGLEngine/NBodyComponent.h b/OpenGLEngine/OpenGLEngine/NBodyComponent.h new file mode 100644 index 0000000..c9b33b8 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NBodyComponent.h @@ -0,0 +1,16 @@ +#pragma once +#include "ECSConfig.h" + + +namespace Reality +{ + struct NBodyComponent + { + NBodyComponent(float _gravityScale = 1.0f) + : gravityScale(_gravityScale) + { + + } + float gravityScale; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/NBodySystem.cpp b/OpenGLEngine/OpenGLEngine/NBodySystem.cpp new file mode 100644 index 0000000..6b08fcf --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NBodySystem.cpp @@ -0,0 +1,52 @@ +#include "NBodySystem.h" +#include "TransformComponent.h" + +namespace Reality +{ + NBodySystem::NBodySystem() + { + requireComponent(); + } + + void NBodySystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& particleTransform = e.getComponent(); + auto& particleForceAcc = e.getComponent(); + + float force = + gravityConstant * ((mass*(1 / particleForceAcc.inverseMass)) / + pow(glm::length(particleTransform.position - centerPoint), 2)); + + particleForceAcc.AddForce((glm::normalize(centerPoint - particleTransform.position) + *force)); + } + if (getEntities().size() > 1) + { + for (int i = 0; i < getEntities().size() - 1; i++) { + for (int j = i + 1; j < getEntities().size() - 1; j++) { + auto& particle1Transform = getEntities()[i].getComponent(); + auto& particle1ForceAcc = getEntities()[i].getComponent(); + auto& particle2Transform = getEntities()[j].getComponent(); + auto& particle2ForceAcc = getEntities()[j].getComponent(); + + float force = + gravityConstant * (((1 / particle1ForceAcc.inverseMass)*(1 / particle2ForceAcc.inverseMass)) / + pow(glm::length(particle1Transform.position - particle2Transform.position), 2)); + + particle1ForceAcc.AddForce((glm::normalize(particle2Transform.position - particle1Transform.position) + *force)); + particle2ForceAcc.AddForce((glm::normalize(particle1Transform.position - particle2Transform.position) + *force)); + + } + } + } + for (auto e : getEntities()){ + if (e.hasComponent()) { + getWorld().data.renderUtil->DrawSphere(centerPoint, 3, Color(1, 1, 1, 1)); + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/NBodySystem.h b/OpenGLEngine/OpenGLEngine/NBodySystem.h new file mode 100644 index 0000000..9f50118 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NBodySystem.h @@ -0,0 +1,17 @@ +#pragma once +#include "ECSConfig.h" +#include "NBodyComponent.h" +#include "ForceAccumulatorComponent.h" + +namespace Reality +{ + class NBodySystem : public ECSSystem + { + public: + NBodySystem(); + void Update(float deltaTime); + float gravityConstant = 5.0f; + Vector3 centerPoint = Vector3(0.0f); + float mass = 100.0f; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/OpenGLEngine.rar b/OpenGLEngine/OpenGLEngine/OpenGLEngine.rar new file mode 100644 index 0000000..08d1f2c Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/OpenGLEngine.rar differ diff --git a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj index dbb8b45..ea9f70e 100644 --- a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj +++ b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj @@ -22,32 +22,32 @@ 15.0 {BF971B9A-9ACC-4B50-8E62-4CC32E780AA5} OpenGLEngine - 10.0.17763.0 + 10.0 Application true - v141 + v142 MultiByte Application false - v141 + v142 true MultiByte Application true - v141 + v142 MultiByte Application false - v141 + v142 true MultiByte @@ -121,30 +121,30 @@ - + + - + - - + - - + + - + - + @@ -160,25 +160,26 @@ - - + + + + + - + + - - - - + @@ -196,25 +197,33 @@ - + + + + + + + + + + + + + - - - - - + - + @@ -222,26 +231,31 @@ - - + - - + - + - + - + + + + + + + + @@ -253,52 +267,42 @@ - + - + - + - + - - - - - - - - - - - + + - + - + - + - @@ -320,42 +324,43 @@ - - - + - + - + - - + - - - + + + - - + - - + + + + + + + - + @@ -379,41 +384,58 @@ - + - + - - - - - - - - - - + - - + + + + + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + @@ -425,37 +447,36 @@ - - - - + - - - + - + - + - - + + - - + - + + + + + + diff --git a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters index 0199877..5de5a42 100644 --- a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters +++ b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters @@ -43,12 +43,39 @@ {09a9940b-c17f-43c0-becf-d8da8efa3d30} - - {1a9d715c-69e4-4d0c-b881-159070a97fa6} - {3f5a8043-c367-47f5-bbe1-005323d21b00} + + {3b57134f-d90e-46bd-8888-c0777df6a173} + + + {2a1ab3ed-c9b4-469a-8efb-a6ad96814ca1} + + + {a47e3b81-90db-42eb-a5f1-e5a072f9b973} + + + {05f83a53-3654-4ae0-99f7-3b5b0131942b} + + + {4c54bdb5-bf1a-46eb-97aa-4ad2f029416e} + + + {8f440b87-7f9c-4d7f-993c-ec5fa08dde39} + + + {8d7d692e-fedf-4e75-9661-f2eb1dd346c1} + + + {fee04adf-2290-4e0b-9dd6-1b2c67f5a98f} + + + {e59d8479-41fd-44e5-91d5-014515c3f2dc} + + + {26df7371-0611-42cd-b6e5-2556995c23d7} + @@ -81,27 +108,9 @@ ECSCore - - TestCS - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - Input - - TestCS - Rendering @@ -126,86 +135,89 @@ Rendering - - TestCS + + Rendering + + + Rendering - + TestCS - + TestCS - - Rendering + + Physics\Particles - - ComponentsCore + + Physics\Particles - - Rendering + + TestCS\FireWorksDemo - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\Gravity - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\Drag - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\FixedSpring - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\PairedSpring - - TestCS + + Physics\Particles - - TestCS + + TestCS\ParticleSphereDemo - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + Physics\Particles - + Rendering - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS - - Physics\Particles + + Physics\Rigidbody Physics\Rigidbody - + Physics\Rigidbody - - Physics\Rigidbody + + TestCS - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Rigidbody + + TestCS\FlightSimulator - - TestCS + + TestCS\FlightSimulator - - Physics\Rigidbody + + Physics\Particles\ForceGenerators\Buoancy @@ -272,42 +284,12 @@ ECSCore - - TestCS - - - TestCS - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - Input Input - - TestCS - - - TestCS - Rendering @@ -332,154 +314,163 @@ Rendering - - TestCS + + Rendering - + TestCS - + TestCS - + TestCS - + TestCS - - TestCS + + Physics\Particles - - ComponentsCore + + Physics\Particles - - ComponentsCore + + Physics\Particles - - Rendering + + Physics\Particles - - TestCS\FlightSim + + TestCS\FireWorksDemo - - TestCS\FlightSim + + TestCS\FireWorksDemo - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\Gravity - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\Gravity - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\Drag - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\Drag - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\FixedSpring - - TestCS\FlightSim + + Physics\Particles\ForceGenerators\FixedSpring - - TestCS + + Physics\Particles\ForceGenerators\PairedSpring - - TestCS + + Physics\Particles\ForceGenerators\PairedSpring - - TestCS + + Physics\Particles - - TestCS + + Physics\Particles + + + TestCS\ParticleSphereDemo + + + TestCS\ParticleSphereDemo - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + Physics\Particles - - TestCS\FlightSim + + Physics\Particles - - TestCS\FlightSim + + ComponentsCore - + Rendering - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS - - Physics\Particles + + Physics\Rigidbody - - Physics\Particles + + Physics\Rigidbody Physics\Rigidbody - + Physics\Rigidbody - + Physics\Rigidbody - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS\FlightSimulator - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Rigidbody + + TestCS\FlightSimulator - - Physics\Rigidbody + + TestCS\FlightSimulator - - TestCS + + TestCS\FlightSimulator - - TestCS + + Physics\Particles\ForceGenerators\Buoancy + + + Physics\Particles\ForceGenerators\Buoancy - + Physics\Rigidbody diff --git a/OpenGLEngine/OpenGLEngine/PairedSpringComponent.h b/OpenGLEngine/OpenGLEngine/PairedSpringComponent.h index 88bf9a9..0511892 100644 --- a/OpenGLEngine/OpenGLEngine/PairedSpringComponent.h +++ b/OpenGLEngine/OpenGLEngine/PairedSpringComponent.h @@ -5,11 +5,20 @@ namespace Reality { struct PairedSpringComponent { - PairedSpringComponent(float _springConstant = 10, float _restLength = 10, ECSEntity a = ECSEntity(), ECSEntity b = ECSEntity()) - :springConstant(_springConstant), restLength(_restLength), entityA(a), entityB(b) {} + PairedSpringComponent(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 entityA; - ECSEntity entityB; + ECSEntity connectedEntityA; + ECSEntity connectedEntityB; }; -} \ No newline at end of file +} diff --git a/OpenGLEngine/OpenGLEngine/PairedSpringSystem.cpp b/OpenGLEngine/OpenGLEngine/PairedSpringSystem.cpp new file mode 100644 index 0000000..70e7b38 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/PairedSpringSystem.cpp @@ -0,0 +1,61 @@ +#include "PairedSpringSystem.h" +#include "TransformComponent.h" +#include "ForceAccumulatorComponent.h" + +namespace Reality +{ + PairedSpringSystem::PairedSpringSystem() + { + requireComponent(); + } + + void PairedSpringSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& spring = e.getComponent(); + + if (spring.connectedEntityA.hasComponent() + && spring.connectedEntityB.hasComponent()) + { + auto& transformA = spring.connectedEntityA.getComponent(); + auto& transformB = spring.connectedEntityB.getComponent(); + + Vector3 relativePosition = transformA.position - transformB.position; + float length = glm::length(relativePosition); + if (length > 0) + { + float deltaL = length - spring.restLength; + Vector3 force = -glm::normalize(relativePosition); + force *= spring.springConstant * deltaL; + + if (spring.connectedEntityA.hasComponent()) + { + spring.connectedEntityA.getComponent().AddForce(force); + } + if (spring.connectedEntityB.hasComponent()) + { + spring.connectedEntityB.getComponent().AddForce(-force); + } + + float g = 1.0f / (1.0f + pow(abs(deltaL), 0.5f)); + float r = 1 - g; + + Color col = Color(r, g, 0, 1); + + float deltaLength = length / 10.0f; + Vector3 direction = glm::normalize(relativePosition); + for (int i = 0; i < 10; i++) + { + getWorld().data.renderUtil->DrawCube( + transformB.position + (float)i * deltaLength * direction, + Vector3(1.0f, 1.0f, 1.0f) * min((spring.restLength / 20.0f), 100.0f), Vector3(0, 0, 0), col); + } + getWorld().data.renderUtil->DrawLine(transformA.position, transformB.position, + col); + } + + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/PairedSpringSystem.h b/OpenGLEngine/OpenGLEngine/PairedSpringSystem.h new file mode 100644 index 0000000..5cf0204 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/PairedSpringSystem.h @@ -0,0 +1,13 @@ +#pragma once +#include "ECSConfig.h" +#include "PairedSpringComponent.h" + +namespace Reality +{ + class PairedSpringSystem : public ECSSystem + { + public: + PairedSpringSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ParticleComponent.h b/OpenGLEngine/OpenGLEngine/ParticleComponent.h index 3c7e057..2580c48 100644 --- a/OpenGLEngine/OpenGLEngine/ParticleComponent.h +++ b/OpenGLEngine/OpenGLEngine/ParticleComponent.h @@ -5,30 +5,12 @@ namespace Reality { struct ParticleComponent { - ParticleComponent(float mass = 1.0f, Vector3 _velocity = Vector3(0,0,0), float _gravityScale = 1) : - velocity(_velocity), gravityScale(_gravityScale) + ParticleComponent(Vector3 _velocity = Vector3(0, 0, 0)) + :velocity(_velocity), acceleration(Vector3(0, 0, 0)) { - inverseMass = 1 / mass; - accelaration = Vector3(0, 0, 0); - forceAccumulator = Vector3(0, 0, 0); + } + Vector3 acceleration; Vector3 velocity; - Vector3 accelaration; - float inverseMass; - float gravityScale; - inline void AddForce(Vector3 force) - { - forceAccumulator += force; - } - inline Vector3 GetForce() - { - return forceAccumulator; - } - inline void ResetForceAccumulator() - { - forceAccumulator = Vector3(0, 0, 0); - } - private: - Vector3 forceAccumulator; }; } diff --git a/OpenGLEngine/OpenGLEngine/ParticleContactEvent.h b/OpenGLEngine/OpenGLEngine/ParticleContactEvent.h new file mode 100644 index 0000000..0d7074e --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ParticleContactEvent.h @@ -0,0 +1,27 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct ParticleContactEvent + { + ParticleContactEvent(ECSEntity _entityA = ECSEntity(), + ECSEntity _entityB = ECSEntity(), + float _restitution = 1.0f, + Vector3 _normal = Vector3(0, 1.0f, 0), + float _penetration = 0.0f) + : entityA(_entityA), + entityB(_entityB), + restitution(_restitution), + normal(_normal), + penetration(_penetration) + { + + } + ECSEntity entityA; + ECSEntity entityB; + float restitution; + Vector3 normal; + float penetration; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.cpp b/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.cpp index 42c892a..0b53901 100644 --- a/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.cpp @@ -1,186 +1,185 @@ #include "ParticleContactResolutionSystem.h" #include "ParticleComponent.h" +#include "ForceAccumulatorSystem.h" #include "TransformComponent.h" +#include "PenetrationDeltaMoveComponent.h" namespace Reality { ParticleContactResolutionSystem::ParticleContactResolutionSystem() { - requireComponent(); + } - float ParticleContactResolutionSystem::CalculateSeparatingVelocity(ParticleContactComponent& contact) + void ParticleContactResolutionSystem::Update(float deltaTime) { - Vector3 velocityA = contact.entityA.hasComponent() ? contact.entityA.getComponent().velocity : Vector3(0, 0, 0); - Vector3 velocityB = contact.entityB.hasComponent() ? contact.entityB.getComponent().velocity : Vector3(0, 0, 0); - Vector3 relativeVel = velocityA - velocityB; - return glm::dot(relativeVel, contact.normal); + auto contactEvents = getWorld().getEventManager().getEvents(); + if (contactEvents.size() > 0) + { + for (int i = 0; i < velocityIterations; i++) + { + // Sort from highest incoming OR most negetive separting velocity to least + std::sort(contactEvents.begin(), contactEvents.end(), + [this](auto a, auto b) + { + return CalculateSeparationVelocity(a) < CalculateSeparationVelocity(b); + }); + ResolveVelocity(contactEvents[0], deltaTime); + } + for (int i = 0; i < positionIterations; i++) + { + // Sort from highest penetration to the least + std::sort(contactEvents.begin(), contactEvents.end(), + [this](auto a, auto b) + { + return CalculateActualPenetration(a) > CalculateActualPenetration(b); + }); + ResolveInterPenetration(contactEvents[0]); + } + } + //for (auto& contact : contactEvents) + //{ + // ResolveVelocity(contact, deltaTime); + // ResolveInterPenetration(contact); + //} } - void ParticleContactResolutionSystem::ResolveVelocity(ParticleContactComponent& contact, float deltaTime) + float ParticleContactResolutionSystem::CalculateSeparationVelocity(ParticleContactEvent & contact) { - float separatingVelocity = CalculateSeparatingVelocity(contact); + Vector3 velocityA = contact.entityA.hasComponent() ? + contact.entityA.getComponent().velocity : Vector3(0, 0, 0); - if (separatingVelocity > 0) - { - return; - } + Vector3 velocityB = contact.entityB.hasComponent() ? + contact.entityB.getComponent().velocity : Vector3(0, 0, 0); - bool isAvalid = contact.entityA.hasComponent(); - bool isBvalid = contact.entityB.hasComponent(); - float invM1 = isAvalid ? contact.entityA.getComponent().inverseMass : 0; - float invM2 = isBvalid ? contact.entityB.getComponent().inverseMass : 0; + Vector3 separationVelocity = velocityA - velocityB; + return glm::dot(separationVelocity, contact.normal); + } - float newSeparatingVelocity = -separatingVelocity * contact.restitution; + float ParticleContactResolutionSystem::CalculateActualPenetration(ParticleContactEvent & contact) + { + float actualPenetration = contact.penetration; - // Check the velocity build up due to accelaration only - Vector3 accCausedVelocity = Vector3(0, 0, 0); - if (isAvalid) - { - accCausedVelocity += contact.entityA.getComponent().accelaration; - } - if (isBvalid) + if (contact.entityA.hasComponent()) { - accCausedVelocity -= contact.entityB.getComponent().accelaration; + Vector3 deltaMove = contact.entityA.getComponent().deltaMove; + actualPenetration -= glm::dot(deltaMove, contact.normal); } - float accCausedSepVelocity = glm::dot(accCausedVelocity, contact.normal) * deltaTime; - // If we have a closing velocity due to accelaration build up, - // remove it from new separating velocity - if (accCausedSepVelocity < 0) + if (contact.entityB.hasComponent()) { - newSeparatingVelocity += contact.restitution * accCausedSepVelocity; - if (newSeparatingVelocity < 0) - { - newSeparatingVelocity = 0; - } + Vector3 deltaMove = contact.entityB.getComponent().deltaMove; + actualPenetration += glm::dot(deltaMove, contact.normal); } - float deltaVelocity = newSeparatingVelocity - separatingVelocity; + return actualPenetration; + } - float totalInverseMass = invM1 + invM2; + void ParticleContactResolutionSystem::ResolveVelocity(ParticleContactEvent & contact, float deltaTime) + { + float initialVelocity = CalculateSeparationVelocity(contact); - if (totalInverseMass <= 0) + if (initialVelocity > 0) { return; } - float impulse = deltaVelocity / totalInverseMass; - - Vector3 impulsePerIMass = contact.normal * impulse; + float finalVelocity = -initialVelocity * contact.restitution; - if (isAvalid) + Vector3 relativeAccelaration = Vector3(0, 0, 0); + if (contact.entityA.hasComponent()) { - contact.entityA.getComponent().velocity += impulsePerIMass * invM1; + relativeAccelaration += contact.entityA.getComponent().acceleration; } - if (isBvalid) + if (contact.entityB.hasComponent()) { - contact.entityB.getComponent().velocity -= impulsePerIMass * invM2; + relativeAccelaration -= contact.entityB.getComponent().acceleration; } - } - void ParticleContactResolutionSystem::ResolveInterpenetration(ParticleContactComponent& contact) - { - if (contact.penetration <= 0) + float accCausedSepVelocity = glm::dot(relativeAccelaration, contact.normal) * deltaTime; + + if (accCausedSepVelocity < 0) { - return; + finalVelocity += contact.restitution * accCausedSepVelocity; + + if (finalVelocity < 0) + { + finalVelocity = 0; + } } - bool isAvalid = contact.entityA.hasComponent(); - bool isBvalid = contact.entityB.hasComponent(); - float invM1 = isAvalid ? contact.entityA.getComponent().inverseMass : 0; - float invM2 = isBvalid ? contact.entityB.getComponent().inverseMass : 0; + float deltaVelocity = finalVelocity - initialVelocity; + + float invMA = contact.entityA.hasComponent() ? + contact.entityA.getComponent().inverseMass : 0; + + float invMB = contact.entityB.hasComponent() ? + contact.entityB.getComponent().inverseMass : 0; - float totalInverseMass = invM1 + invM2; + float totalInverseMass = invMA + invMB; if (totalInverseMass <= 0) { return; } - Vector3 movePerMass = contact.normal * (-contact.penetration / totalInverseMass); - contact.deltaMovePerMass = movePerMass; - if (isAvalid) + float impulse = deltaVelocity / totalInverseMass; + Vector3 impulsePerIMass = impulse * contact.normal; + + if (contact.entityA.hasComponent()) { - contact.entityA.getComponent().position -= movePerMass * invM1; + contact.entityA.getComponent().velocity += impulsePerIMass * invMA; } - if (isBvalid) + if (contact.entityB.hasComponent()) { - contact.entityB.getComponent().position += movePerMass * invM2; + contact.entityB.getComponent().velocity -= impulsePerIMass * invMB; } - //contact.penetration = 0; } - - void ParticleContactResolutionSystem::UpdateInterpenetration(ParticleContactComponent & bestContact, ParticleContactComponent & contact) + void ParticleContactResolutionSystem::ResolveInterPenetration(ParticleContactEvent & contact) { - bool isAvalid = contact.entityA.hasComponent(); - bool isBvalid = contact.entityB.hasComponent(); - float invM1 = isAvalid ? contact.entityA.getComponent().inverseMass : 0; - float invM2 = isBvalid ? contact.entityB.getComponent().inverseMass : 0; - if (bestContact.entityA == contact.entityA || bestContact.entityB == contact.entityA) + float actualPenetration = CalculateActualPenetration(contact); + + if (actualPenetration < 0) { - float mult = bestContact.entityA == contact.entityA ? -1 : 1; - Vector3 deltaMove = mult * bestContact.deltaMovePerMass * invM1; - float deltaPenetration = glm::dot(deltaMove, contact.normal); - contact.penetration -= deltaPenetration; + return; } - if (bestContact.entityB == contact.entityB || bestContact.entityA == contact.entityB) + + float invMassA = contact.entityA.hasComponent() ? + contact.entityA.getComponent().inverseMass : 0; + + float invMassB = contact.entityB.hasComponent() ? + contact.entityB.getComponent().inverseMass : 0; + + float totalInverseMass = invMassA + invMassB; + + if (totalInverseMass <= 0) { - float mult = bestContact.entityA == contact.entityB ? -1 : 1; - Vector3 deltaMove = mult * bestContact.deltaMovePerMass * invM2; - float deltaPenetration = glm::dot(deltaMove, contact.normal); - contact.penetration += deltaPenetration; + return; } - } - void ParticleContactResolutionSystem::Update(float deltaTime) - { - iterationsUsed = 0; - iterations = getEntities().size() * 2; + Vector3 movePerUnitIMass = contact.normal * (actualPenetration / totalInverseMass); - if (getEntities().size() > 0) + if (contact.entityA.hasComponent()) { - unsigned int bestContactIndex = 0; - unsigned int lastBest = 0; - while (iterationsUsed < iterations) + Vector3 deltaMove = movePerUnitIMass * invMassA; + contact.entityA.getComponent().position += deltaMove; + if (contact.entityA.hasComponent()) { - // Find the contact with the largest closing velocity - float max = 0; - for (int i = 0; i < getEntities().size(); i++) - { - auto e = getEntities()[i]; - auto &contact = e.getComponent(); - if (iterationsUsed > 0) - { - UpdateInterpenetration(getEntities()[lastBest].getComponent(), contact); - } - float sepVel = CalculateSeparatingVelocity(contact); - if (sepVel < max) - { - max = sepVel; - bestContactIndex = i; - } - } - if (max >= 0) - { - break; - } - auto& bestContact = getEntities()[bestContactIndex].getComponent(); - ResolveVelocity(bestContact, deltaTime); - ResolveInterpenetration(bestContact); - lastBest = bestContactIndex; - iterationsUsed++; + contact.entityA.getComponent().deltaMove += deltaMove; } + } - for (auto e : getEntities()) + if (contact.entityB.hasComponent()) + { + Vector3 deltaMove = movePerUnitIMass * invMassB; + contact.entityB.getComponent().position -= movePerUnitIMass * invMassB; + if (contact.entityB.hasComponent()) { - e.kill(); + contact.entityB.getComponent().deltaMove -= deltaMove; } } - - } } diff --git a/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.h b/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.h index ff0daa1..a203f9b 100644 --- a/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.h +++ b/OpenGLEngine/OpenGLEngine/ParticleContactResolutionSystem.h @@ -1,6 +1,6 @@ #pragma once #include "ECSConfig.h" -#include "ParticleContactComponent.h" +#include "ParticleContactEvent.h" namespace Reality { @@ -9,13 +9,12 @@ namespace Reality public: ParticleContactResolutionSystem(); void Update(float deltaTime); - unsigned int iterations = 1; private: - float CalculateSeparatingVelocity(ParticleContactComponent& contact); - void ResolveVelocity(ParticleContactComponent& contact, float deltaTime); - void ResolveInterpenetration(ParticleContactComponent& contact); - void UpdateInterpenetration(ParticleContactComponent& bestContact, ParticleContactComponent& contact); - unsigned int iterationsUsed = 0; + float CalculateSeparationVelocity(ParticleContactEvent& contact); + float CalculateActualPenetration(ParticleContactEvent& contact); + void ResolveVelocity(ParticleContactEvent& contact, float deltaTime); + void ResolveInterPenetration(ParticleContactEvent& contact); + int velocityIterations = 4; + int positionIterations = 8; }; } - diff --git a/OpenGLEngine/OpenGLEngine/ParticleSphereComponent.h b/OpenGLEngine/OpenGLEngine/ParticleSphereComponent.h new file mode 100644 index 0000000..4954332 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ParticleSphereComponent.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct ParticleSphereComponent + { + ParticleSphereComponent(float _radius = 1.0f) + : radius(_radius) + { + + } + float radius; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ParticleSphereSystem.cpp b/OpenGLEngine/OpenGLEngine/ParticleSphereSystem.cpp new file mode 100644 index 0000000..bd2cc30 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ParticleSphereSystem.cpp @@ -0,0 +1,145 @@ +#include "ParticleSphereSystem.h" +#include "ParticleContactEvent.h" + +namespace Reality +{ + ParticleSphereSystem::ParticleSphereSystem() + { + requireComponent(); + requireComponent(); + } + + void ParticleSphereSystem::Update(float deltaTime) + { + if (!createBox) + { + boundingBox = getWorld().createEntity(); + createBox = true; + } + + // Draw Bounding Box + if (getEntities().size() > 0) + { + getWorld().data.renderUtil->DrawCube( + Vector3(0, 0, 0), + Vector3(20, 20, 20), + Vector3(0, 0, 0), + Color::Purple + ); + } + + for (int i = 0; i < getEntities().size(); i++) + { + auto e = getEntities()[i]; + auto& transform = e.getComponent(); + auto& sphere = e.getComponent(); + + // Draw Debug Sphere + if (DEBUG_LOG_LEVEL > 0) + { + getWorld().data.renderUtil->DrawSphere( + transform.position, + sphere.radius, + Color::Orange + ); + } + + // Collision Check with X + if (abs(transform.position.x) + sphere.radius >= 10) + { + Vector3 normal = Vector3(transform.position.x > 0 ? -1 : 1, 0, 0); + float penetration = abs(transform.position.x) + sphere.radius - 10; + + getWorld().getEventManager().emitEvent( + e, + boundingBox, + 0.8f, + normal, + penetration); + + getWorld().data.renderUtil->DrawLine( + transform.position - normal * sphere.radius, + transform.position - normal * (sphere.radius - penetration), + Color::Red); + } + + // Collision Check with Y + if (abs(transform.position.y) + sphere.radius >= 10) + { + Vector3 normal = Vector3(0, transform.position.y > 0 ? -1 : 1, 0); + float penetration = abs(transform.position.y) + sphere.radius - 10; + + getWorld().getEventManager().emitEvent( + e, + boundingBox, + 0.8f, + normal, + penetration); + + getWorld().data.renderUtil->DrawLine( + transform.position - normal * sphere.radius, + transform.position - normal * (sphere.radius - penetration), + Color::Red); + } + + // Collision Check with Z + if (abs(transform.position.z) + sphere.radius >= 10) + { + Vector3 normal = Vector3(0, 0, transform.position.z > 0 ? -1 : 1); + float penetration = abs(transform.position.z) + sphere.radius - 10; + + getWorld().getEventManager().emitEvent( + e, + boundingBox, + 0.8f, + normal, + penetration); + + getWorld().data.renderUtil->DrawLine( + transform.position - normal * sphere.radius, + transform.position - normal * (sphere.radius - penetration), + Color::Red); + } + + // Collision with other spheres + if (i < getEntities().size() - 1) + { + for (int j = i + 1; j < getEntities().size(); j++) + { + CheckCollision(e, getEntities()[j]); + } + } + } + } + void ParticleSphereSystem::CheckCollision(ECSEntity sphereEntityA, ECSEntity sphereEntityB) + { + auto& transformA = sphereEntityA.getComponent(); + auto& sphereA = sphereEntityA.getComponent(); + + auto& transformB = sphereEntityB.getComponent(); + auto& sphereB = sphereEntityB.getComponent(); + + Vector3 relativePos = transformA.position - transformB.position; + float distance = glm::length(relativePos); + + if (distance < sphereA.radius + sphereB.radius) + { + Vector3 normal = glm::normalize(relativePos); + float penetration = sphereA.radius + sphereB.radius - distance; + + getWorld().getEventManager().emitEvent( + sphereEntityA, + sphereEntityB, + 0.8f, + normal, + penetration + ); + + getWorld().data.renderUtil->DrawLine( + transformA.position - normal * sphereA.radius, + transformB.position + normal * sphereB.radius, + Color::Red + ); + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/ParticleSphereSystem.h b/OpenGLEngine/OpenGLEngine/ParticleSphereSystem.h new file mode 100644 index 0000000..0bda2db --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ParticleSphereSystem.h @@ -0,0 +1,18 @@ +#pragma once +#include "ECSConfig.h" +#include "ParticleSphereComponent.h" +#include "TransformComponent.h" + +namespace Reality +{ + class ParticleSphereSystem : public ECSSystem + { + public: + ParticleSphereSystem(); + void Update(float deltaTime); + private: + bool createBox = false; + ECSEntity boundingBox; + void CheckCollision(ECSEntity sphereEntityA, ECSEntity sphereEntityB); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ParticleSystem.cpp b/OpenGLEngine/OpenGLEngine/ParticleSystem.cpp index 41744a2..c9b3b97 100644 --- a/OpenGLEngine/OpenGLEngine/ParticleSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/ParticleSystem.cpp @@ -1,6 +1,5 @@ #include "ParticleSystem.h" - namespace Reality { ParticleSystem::ParticleSystem() @@ -13,21 +12,16 @@ namespace Reality { for (auto e : getEntities()) { - auto &particle = e.getComponent(); - auto &transform = e.getComponent(); + auto& transform = e.getComponent(); + auto& particle = e.getComponent(); + + particle.velocity += particle.acceleration * deltaTime; + transform.position += particle.velocity * deltaTime; - // HACK for bounce - if (transform.position.y <= -10) + if (DEBUG_LOG_LEVEL > 0) { - //particle.velocity.y = -particle.velocity.y; - //e.kill(); + getWorld().data.renderUtil->DrawSphere(transform.position); } - - // Update velocity from accelarartion - particle.velocity += particle.accelaration * deltaTime; - - // Update position from velocity - transform.position += particle.velocity * deltaTime; } } } diff --git a/OpenGLEngine/OpenGLEngine/ParticleSystem.h b/OpenGLEngine/OpenGLEngine/ParticleSystem.h index 4c69212..2c926e8 100644 --- a/OpenGLEngine/OpenGLEngine/ParticleSystem.h +++ b/OpenGLEngine/OpenGLEngine/ParticleSystem.h @@ -12,4 +12,3 @@ namespace Reality void Update(float deltaTime); }; } - diff --git a/OpenGLEngine/OpenGLEngine/PenetrationDeltaMoveComponent.h b/OpenGLEngine/OpenGLEngine/PenetrationDeltaMoveComponent.h new file mode 100644 index 0000000..fb50100 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/PenetrationDeltaMoveComponent.h @@ -0,0 +1,14 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct PenetrationDeltaMoveComponent + { + PenetrationDeltaMoveComponent() : deltaMove(Vector3(0, 0, 0)) + { + + } + Vector3 deltaMove; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/PlaneComponent.h b/OpenGLEngine/OpenGLEngine/PlaneComponent.h new file mode 100644 index 0000000..8446f8b --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/PlaneComponent.h @@ -0,0 +1,21 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct PlaneComponent + { + PlaneComponent(ECSEntity a = ECSEntity(), + ECSEntity b = ECSEntity(), + ECSEntity c = ECSEntity()) + : entityA(a), + entityB(b), + entityC(c) + { + + } + ECSEntity entityA; + ECSEntity entityB; + ECSEntity entityC; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/PlaneSystem.cpp b/OpenGLEngine/OpenGLEngine/PlaneSystem.cpp new file mode 100644 index 0000000..5f57387 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/PlaneSystem.cpp @@ -0,0 +1,161 @@ +#include "PlaneSystem.h" +#include "TransformComponent.h" +#include "ParticleSphereComponent.h" +#include "ParticleContactEvent.h" +#include "ParticleComponent.h" +#include "ForceAccumulatorComponent.h" +#include "GravityForceComponent.h" + +namespace Reality +{ + PlaneSystem::PlaneSystem() + { + + } + + //Find the plane entities, and compare each individually to the spheres + void PlaneSystem::Update(float deltaTime) + { + if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_E) == GLFW_PRESS) + { + for (auto e2 : getEntities()) + { + if (e2.hasComponent()) // True = Entity has a Sphere + { + e2.kill(); + } + } + + auto sphere = getWorld().createEntity(); + sphere.addComponent(Vector3(-15, 12, 2)); + sphere.addComponent(); + sphere.addComponent(1.0f); + sphere.addComponent(); + sphere.addComponent(); + } + if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_R) == GLFW_PRESS) + { + for (auto e2 : getEntities()) + { + if (e2.hasComponent()) // True = Entity has a Sphere + { + e2.kill(); + } + } + + auto sphere = getWorld().createEntity(); + sphere.addComponent(Vector3(15, 12, -2)); + sphere.addComponent(); + sphere.addComponent(1.0f); + sphere.addComponent(); + sphere.addComponent(); + } + for (auto e : getEntities()) + { + if (e.hasComponent()) // True = Entity has a Plane + { + auto& plane = e.getComponent(); + bool hasCollided = false; + + if (plane.entityA.hasComponent() && + plane.entityB.hasComponent() && + plane.entityC.hasComponent()) + { + auto& transformA = plane.entityA.getComponent(); + auto& transformB = plane.entityB.getComponent(); + auto& transformC = plane.entityC.getComponent(); + + //Step 1: Calculate the plane equation, normal + Vector3 v1 = transformB.position - transformA.position; // AB + Vector3 v2 = transformC.position - transformA.position; // AC + Vector4 norm = Vector4(glm::cross(v1, v2), 0.0f); // Leave space for D of Plane Equation + norm.w = // Substitute point entity A to solve for D + -(norm.x * transformA.position.x) + - (norm.y * transformA.position.y) + - (norm.z * transformA.position.z); + for (auto e2 : getEntities()) + { + if (e2.hasComponent()) // True = Entity has a Sphere + { + auto& sphere = e2.getComponent(); + if (e2.hasComponent()) + { + auto& sphereTransform = e2.getComponent(); + //Step 2: Calculate nearest possible point on plane + // 2A: length of normal to sphere center + float d = glm::dot(glm::normalize(Vector3(norm)), sphereTransform.position - transformA.position); + // 2B: find point + Vector3 point = glm::normalize(Vector3(norm)) * (-d) + sphereTransform.position; + + //getWorld().data.renderUtil->DrawSphere(point, 0.5f, Color::Blue); // Renders nearest point on plane + //Step 3: Find distance + float dist = glm::distance(point, sphereTransform.position); + if (dist < sphere.radius) + { + //Step 4: Determine if point is within triangle + // TODO: Find closest points/vertices and try and find closest point to 'point' if this next step fails + // This would catch side-collisions + float A = Area(transformA.position, transformB.position, transformC.position); + float A1 = Area(point, transformB.position, transformC.position); + float A2 = Area(transformA.position, point, transformC.position); + float A3 = Area(transformA.position, transformB.position, point); + + if (abs(A - A1 - A2 - A3) < 0.001f) // Within triangle + { + // Collision + float penetration = sphere.radius - dist; + + /*getWorld().getEventManager().emitEvent( + e2, + e, + 0.5f, + glm::normalize(Vector3(norm)), + penetration);*/ + + getWorld().getEventManager().emitEvent( + e2, + plane.entityA, + 1.0f, + glm::normalize(Vector3(norm)), + penetration); + + getWorld().getEventManager().emitEvent( + e2, + plane.entityB, + 1.0f, + glm::normalize(Vector3(norm)), + penetration); + + getWorld().getEventManager().emitEvent( + e2, + plane.entityC, + 1.0f, + glm::normalize(Vector3(norm)), + penetration); + + getWorld().data.renderUtil->DrawLine( + sphereTransform.position - Vector3(norm) * sphere.radius, + sphereTransform.position - Vector3(norm) * (sphere.radius - penetration), + Color::Red); + + hasCollided = true; + } + } + } + } + } + if (hasCollided) + getWorld().data.renderUtil->DrawTriangle(transformA.position, transformB.position, transformC.position, Color::Red); + else { + getWorld().data.renderUtil->DrawTriangle(transformA.position, transformB.position, transformC.position, Color::Green); + } + } + } + } + } + float PlaneSystem::Area(Vector3 p1, Vector3 p2, Vector3 p3) + {//=ABS(A1*(SQRT(POWER(B2-B3,2)+POWER(C2-C3,2)))+A2*(SQRT(POWER(B3-B1,2)+POWER(C3-C1,2)))+A3*(SQRT(POWER(B1-B2,2)+POWER(C1-C2,2)))) + Vector3 mid = p2 + (glm::normalize(p3 - p2)) * glm::dot(glm::normalize(p3 - p2), p1 - p2); + return glm::distance(p3,p2) * glm::distance(p1, mid) * 0.5f; + } +} \ No newline at end of file diff --git a/OpenGLEngine/OpenGLEngine/PlaneSystem.h b/OpenGLEngine/OpenGLEngine/PlaneSystem.h new file mode 100644 index 0000000..5e10626 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/PlaneSystem.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" +#include "PlaneComponent.h" + +namespace Reality +{ + class PlaneSystem : public ECSSystem + { + public: + PlaneSystem(); + void Update(float deltaTime); + private: + float Area(Vector3, Vector3, Vector3); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/RenderUtil.cpp b/OpenGLEngine/OpenGLEngine/RenderUtil.cpp index cfadec7..2bd8400 100644 --- a/OpenGLEngine/OpenGLEngine/RenderUtil.cpp +++ b/OpenGLEngine/OpenGLEngine/RenderUtil.cpp @@ -576,6 +576,10 @@ namespace Reality glm::vec3 position = (start + end) * 0.5f; float scale = glm::length(start - end); glm::vec3 axis = glm::cross(glm::vec3(1, 0, 0), end - start); + if (glm::length(axis) < 0.001f) + { + axis = glm::vec3(1, 0, 0); + } axis = glm::normalize(axis); float proj = glm::dot(end - start, glm::vec3(1, 0, 0)); glm::mat4 model = glm::mat4(1.0f); diff --git a/OpenGLEngine/OpenGLEngine/RenderingSystem.cpp b/OpenGLEngine/OpenGLEngine/RenderingSystem.cpp index b11bd6d..0f4663a 100644 --- a/OpenGLEngine/OpenGLEngine/RenderingSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/RenderingSystem.cpp @@ -25,7 +25,7 @@ namespace Reality } for (auto e : getEntities()) { - const auto transform = e.getComponent(); + auto &transform = e.getComponent(); auto &mesh = e.getComponent(); if (getWorld().data.assetLoader->ModelsLoaded()) @@ -41,10 +41,18 @@ namespace Reality getWorld().data.renderUtil->DrawModel(mesh.modelId, transform.position, transform.scale, transform.eulerAngles, drawModes[drawMode]); } - // Draw - //getWorld().data.renderUtil->DrawCube(transform.position, Vector3(10,10,10), transform.eulerAngles); - //getWorld().data.renderUtil->DrawCube(transform.position + Vector3(0, transform.scale.y , 0) * 7.5f, transform.scale * 15.0f, transform.eulerAngles); - //getWorld().data.renderUtil->DrawLine(transform.position - Vector3(1, 1, 1), transform.position + Vector3(1, 1, 1)); + if (DEBUG_LOG_LEVEL > 0) + { + // X + getWorld().data.renderUtil->DrawLine(transform.position, + transform.position + transform.Right() * 10.0f, Color::Red); + // Y + getWorld().data.renderUtil->DrawLine(transform.position, + transform.position + transform.Up() * 10.0f, Color::Green); + // Z + getWorld().data.renderUtil->DrawLine(transform.position, + transform.position + transform.Forward() * 10.0f, Color::Blue); + } } } } diff --git a/OpenGLEngine/OpenGLEngine/RenderingSystemV2.cpp b/OpenGLEngine/OpenGLEngine/RenderingSystemV2.cpp index aa2dbef..a31ab95 100644 --- a/OpenGLEngine/OpenGLEngine/RenderingSystemV2.cpp +++ b/OpenGLEngine/OpenGLEngine/RenderingSystemV2.cpp @@ -1,4 +1,7 @@ #include "RenderingSystemV2.h" +#include "Shader.h" +#include "Camera.h" +#include namespace Reality { @@ -10,31 +13,46 @@ namespace Reality void RenderingSystemV2::Update(float deltaTime) { + if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_F1) == GLFW_PRESS && !drawModeChanged) + { + drawMode++; + drawMode = drawMode % 2; + drawModeChanged = true; + } + else if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_F1) == GLFW_RELEASE) + { + drawModeChanged = false; + } for (auto e : getEntities()) { - auto& transform = e.getComponent(); - auto &model = e.getComponent(); + auto &transform = e.getComponent(); + auto &mesh = e.getComponent(); if (getWorld().data.assetLoader->ModelsLoaded()) { getWorld().data.assetLoader->SetLight(getWorld().data.renderUtil->camera.Position); } - if (model.modelId < 0) + if (mesh.modelId < 0) { - model.modelId = getWorld().data.assetLoader->GetModelId(model.mesh); + mesh.modelId = getWorld().data.assetLoader->GetModelId(mesh.mesh); } - if (model.modelId >= 0) + if (mesh.modelId >= 0) + { + getWorld().data.renderUtil->DrawModel(mesh.modelId, transform.GetTransformationMatrix() * mesh.GetModelOffsetTransformation(), drawModes[drawMode]); + } + + if (DEBUG_LOG_LEVEL > 0) { - //Mat4 modelMat = glm::translate(glm::mat4(1.0f), model.offset.x * transform.Right() + model.offset.y * transform.Up() + model.offset.z * transform.Forward()) * transform.transformationMatrix; - //Mat4 modelMat = glm::translate(transform.transformationMatrix, model.offset.x * transform.Right() + model.offset.y * transform.Up() + model.offset.z * transform.Forward()); - glm::vec3 rotationOffsetInRads = glm::vec3(glm::radians(model.rotation.x), glm::radians(model.rotation.y), glm::radians(model.rotation.z)); - glm::mat4 rotationOffsetMat = glm::toMat4(glm::quat(rotationOffsetInRads)); - Mat4 modelMat = transform.GetTransformationMatrix() * glm::translate(glm::mat4(1.0f), model.offset) * rotationOffsetMat; - getWorld().data.renderUtil->DrawModel(model.modelId, modelMat); + // X + getWorld().data.renderUtil->DrawLine(transform.GetPosition(), + transform.GetPosition() + transform.Right() * 10.0f, Color::Red); + // Y + getWorld().data.renderUtil->DrawLine(transform.GetPosition(), + transform.GetPosition() + transform.Up() * 10.0f, Color::Green); + // Z + getWorld().data.renderUtil->DrawLine(transform.GetPosition(), + transform.GetPosition() + transform.Forward() * 10.0f, Color::Blue); } - getWorld().data.renderUtil->DrawLine(transform.GetPosition(), transform.GetPosition() + transform.Right() * 10.0f, Color::Red); - getWorld().data.renderUtil->DrawLine(transform.GetPosition(), transform.GetPosition() + transform.Up() * 10.0f, Color::Green); - getWorld().data.renderUtil->DrawLine(transform.GetPosition(), transform.GetPosition() + transform.Forward() * 10.0f, Color::Blue); } } } diff --git a/OpenGLEngine/OpenGLEngine/RenderingSystemV2.h b/OpenGLEngine/OpenGLEngine/RenderingSystemV2.h index b2a18e5..610bfbe 100644 --- a/OpenGLEngine/OpenGLEngine/RenderingSystemV2.h +++ b/OpenGLEngine/OpenGLEngine/RenderingSystemV2.h @@ -2,6 +2,10 @@ #include "ECSConfig.h" #include "TransformComponentV2.h" #include "MeshComponent.h" + +class Shader; +class Camera; + namespace Reality { class RenderingSystemV2 : public ECSSystem @@ -9,5 +13,9 @@ namespace Reality public: RenderingSystemV2(); void Update(float deltaTime); + private: + unsigned int drawMode = 0; + unsigned int drawModes[2] = { GL_FILL, GL_LINE }; + bool drawModeChanged = false; }; } diff --git a/OpenGLEngine/OpenGLEngine/ResetPenetrationDeltaMoveSystem.cpp b/OpenGLEngine/OpenGLEngine/ResetPenetrationDeltaMoveSystem.cpp new file mode 100644 index 0000000..8b1d203 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ResetPenetrationDeltaMoveSystem.cpp @@ -0,0 +1,18 @@ +#include "ResetPenetrationDeltaMoveSystem.h" + +namespace Reality +{ + ResetPenetrationDeltaMoveSystem::ResetPenetrationDeltaMoveSystem() + { + requireComponent(); + } + + void ResetPenetrationDeltaMoveSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& penetration = e.getComponent(); + penetration.deltaMove = Vector3(0, 0, 0); + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/ResetPenetrationDeltaMoveSystem.h b/OpenGLEngine/OpenGLEngine/ResetPenetrationDeltaMoveSystem.h new file mode 100644 index 0000000..958dfed --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ResetPenetrationDeltaMoveSystem.h @@ -0,0 +1,13 @@ +#pragma once +#include "ECSConfig.h" +#include "PenetrationDeltaMoveComponent.h" + +namespace Reality +{ + class ResetPenetrationDeltaMoveSystem : public ECSSystem + { + public: + ResetPenetrationDeltaMoveSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/43-65-sailboat/for_texturing.png b/OpenGLEngine/OpenGLEngine/Resources/Models/43-65-sailboat/for_texturing.png new file mode 100644 index 0000000..a8fa54d Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/43-65-sailboat/for_texturing.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/43-65-sailboat/parus2.png b/OpenGLEngine/OpenGLEngine/Resources/Models/43-65-sailboat/parus2.png new file mode 100644 index 0000000..eb1d506 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/43-65-sailboat/parus2.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat.jpg new file mode 100644 index 0000000..9df362b Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat.max b/OpenGLEngine/OpenGLEngine/Resources/Models/boat.max new file mode 100644 index 0000000..d2a6563 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat.max differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat/Vagabond.mtl b/OpenGLEngine/OpenGLEngine/Resources/Models/boat/Vagabond.mtl new file mode 100644 index 0000000..0ab2963 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/Resources/Models/boat/Vagabond.mtl @@ -0,0 +1,86 @@ +# Blender MTL File: 'Vagabond.blend' +# Material Count: 9 + +newmtl InvDeck +Ns 96.078431 +Ka 0.060056 0.060056 0.060056 +Kd 0.330827 0.330827 0.330827 +Ks 0.000000 0.000000 0.000000 +Ni 1.000000 +d 0.100000 +illum 0 + +newmtl Material +Ns 349.019608 +Ka 0.037733 0.037733 0.037733 +Kd 0.065669 0.136811 0.109991 +Ks 0.733678 0.733678 0.733678 +Ni 1.000000 +d 0.662524 +illum 2 + +newmtl Red +Ns 1000.000000 +Ka 0.019482 0.019482 0.019482 +Kd 0.700000 0.011047 0.021744 +Ks 0.386484 0.780355 0.700265 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl SailMtl +Ns 19.607843 +Ka 0.031696 0.031696 0.031696 +Kd 1.000000 0.911088 0.789181 +Ks 0.251000 0.251000 0.251000 +Ni 1.000000 +d 0.900000 +illum 2 + +newmtl WhiteBase.000 +Ns 19.607843 +Ka 0.031696 0.031696 0.031696 +Kd 1.000000 0.960000 0.960000 +Ks 0.251000 0.251000 0.251000 +Ni 1.000000 +d 1.000000 +illum 2 +map_Kd wood-textures-high-quality-1.jpg + +newmtl WhiteBase.001 +Ns 19.607843 +Ka 0.031696 0.031696 0.031696 +Kd 1.000000 0.960000 0.960000 +Ks 0.251000 0.251000 0.251000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl Wood +Ns 815.686275 +Ka 0.000000 0.000000 0.000000 +Kd 0.502484 0.438928 0.357545 +Ks 0.600736 0.600736 0.600736 +Ni 1.000000 +d 1.000000 +illum 2 +map_Kd wood-textures-high-quality-1.jpg + +newmtl Wood_NONE +Ns 815.686275 +Ka 0.000000 0.000000 0.000000 +Kd 0.502484 0.438928 0.357545 +Ks 0.600736 0.600736 0.600736 +Ni 1.000000 +d 1.000000 +illum 2 +map_Kd wood-textures-high-quality-1.jpg + +newmtl chrome +Ns 598.039216 +Ka 0.190178 0.190178 0.190178 +Kd 0.228413 0.235303 0.232253 +Ks 1.000000 1.000000 1.000000 +Ni 1.000000 +d 1.000000 +illum 2 diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat/wood-textures-high-quality-1.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat/wood-textures-high-quality-1.jpg new file mode 100644 index 0000000..f86a76e Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat/wood-textures-high-quality-1.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat1.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat1.jpg new file mode 100644 index 0000000..15bc9c9 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat1.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat2.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2.jpg new file mode 100644 index 0000000..c2873ad Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat.jpg new file mode 100644 index 0000000..9df362b Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat.max b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat.max new file mode 100644 index 0000000..d2a6563 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat.max differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat1.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat1.jpg new file mode 100644 index 0000000..15bc9c9 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat1.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat2.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat2.jpg new file mode 100644 index 0000000..c2873ad Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/boat2/boat2.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/source/Unity2Skfb.fbx b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/source/Unity2Skfb.fbx new file mode 100644 index 0000000..4449b50 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/source/Unity2Skfb.fbx differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH2_LOD2_S3a.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH2_LOD2_S3a.png new file mode 100644 index 0000000..a16384f Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH2_LOD2_S3a.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH2_LOD3_slod3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH2_LOD3_slod3.png new file mode 100644 index 0000000..84eb3bd Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH2_LOD3_slod3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH3_SLOD3_1_B.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH3_SLOD3_1_B.png new file mode 100644 index 0000000..4d14898 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH3_SLOD3_1_B.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH3_SLOD3_2.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH3_SLOD3_2.png new file mode 100644 index 0000000..0c5cd2d Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CH3_SLOD3_2.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_13_LAND_SLOD3_D.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_13_LAND_SLOD3_D.png new file mode 100644 index 0000000..6a93d0e Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_13_LAND_SLOD3_D.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15_SLOD3new.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15_SLOD3new.png new file mode 100644 index 0000000..d3f1000 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15_SLOD3new.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15b_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15b_SLOD3.png new file mode 100644 index 0000000..0d84331 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15b_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15c_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15c_SLOD3.png new file mode 100644 index 0000000..8e6160c Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_15c_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_LOD2_SLOD3_A.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_LOD2_SLOD3_A.png new file mode 100644 index 0000000..498ee97 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS1_LOD2_SLOD3_A.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS2_10_SLOD3a.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS2_10_SLOD3a.png new file mode 100644 index 0000000..d920a71 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS2_10_SLOD3a.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS2_LOD_1234_S3new.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS2_LOD_1234_S3new.png new file mode 100644 index 0000000..5fd8814 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS2_LOD_1234_S3new.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS3_02_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS3_02_SLOD3.png new file mode 100644 index 0000000..f69fec7 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS3_02_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS3_05_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS3_05_SLOD3.png new file mode 100644 index 0000000..e8bad86 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS3_05_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS4_LOD_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS4_LOD_SLOD3.png new file mode 100644 index 0000000..1af8d07 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS4_LOD_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS5_LOD_01_04_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS5_LOD_01_04_SLOD3.png new file mode 100644 index 0000000..b819a5d Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS5_LOD_01_04_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS5_LOD_2_3_SLOD3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS5_LOD_2_3_SLOD3.png new file mode 100644 index 0000000..7fccc60 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS5_LOD_2_3_SLOD3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_01.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_01.png new file mode 100644 index 0000000..5eeb41c Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_01.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_02.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_02.png new file mode 100644 index 0000000..2dcc16d Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_02.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_03.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_03.png new file mode 100644 index 0000000..e578e1e Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_03.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_04.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_04.png new file mode 100644 index 0000000..33325b2 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/CS6_LOD_SLOD3_04.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/Ch3_slod3_08_09.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/Ch3_slod3_08_09.png new file mode 100644 index 0000000..06af2da Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/Ch3_slod3_08_09.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/DT1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/DT1_SLOD4.png new file mode 100644 index 0000000..819d045 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/DT1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/GTAV-HD-MAP-satellite.jpeg b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/GTAV-HD-MAP-satellite.jpeg new file mode 100644 index 0000000..7732073 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/GTAV-HD-MAP-satellite.jpeg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/HW1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/HW1_SLOD4.png new file mode 100644 index 0000000..44e13a9 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/HW1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ID1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ID1_SLOD4.png new file mode 100644 index 0000000..b76d58d Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ID1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/KT1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/KT1_SLOD4.png new file mode 100644 index 0000000..66f32db Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/KT1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/PO1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/PO1_SLOD4.png new file mode 100644 index 0000000..2a3ca4f Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/PO1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SC1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SC1_SLOD4.png new file mode 100644 index 0000000..3408640 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SC1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SM1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SM1_SLOD4.png new file mode 100644 index 0000000..16fbd08 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SM1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SP1_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SP1_SLOD4.png new file mode 100644 index 0000000..252085b Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/SP1_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/VB_LOD_SLOD4.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/VB_LOD_SLOD4.png new file mode 100644 index 0000000..f53db56 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/VB_LOD_SLOD4.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ap1_slod4b_B.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ap1_slod4b_B.png new file mode 100644 index 0000000..8977102 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ap1_slod4b_B.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/bh_lod_slod3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/bh_lod_slod3.png new file mode 100644 index 0000000..1d59116 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/bh_lod_slod3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch1_lod_slod3a.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch1_lod_slod3a.png new file mode 100644 index 0000000..71cd076 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch1_lod_slod3a.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch1_lod_slod3c.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch1_lod_slod3c.png new file mode 100644 index 0000000..0004aee Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch1_lod_slod3c.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch3_01_02_slod3_B.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch3_01_02_slod3_B.png new file mode 100644 index 0000000..46b08de Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch3_01_02_slod3_B.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch3_03_04_slod3_B.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch3_03_04_slod3_B.png new file mode 100644 index 0000000..787399e Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ch3_03_04_slod3_B.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs1_16_slod3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs1_16_slod3.png new file mode 100644 index 0000000..bed8e37 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs1_16_slod3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs2_08_slod3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs2_08_slod3.png new file mode 100644 index 0000000..701dd5b Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs2_08_slod3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs3_01_slod3_00.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs3_01_slod3_00.png new file mode 100644 index 0000000..753d533 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs3_01_slod3_00.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs3_08_slod3aa.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs3_08_slod3aa.png new file mode 100644 index 0000000..6e39a1d Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs3_08_slod3aa.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs4_lod_MR1_slod3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs4_lod_MR1_slod3.png new file mode 100644 index 0000000..3c0626a Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/cs4_lod_MR1_slod3.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/gradient_circle.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/gradient_circle.png new file mode 100644 index 0000000..3e6e08f Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/gradient_circle.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/id2_slod4_tg.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/id2_slod4_tg.png new file mode 100644 index 0000000..d1d28b5 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/id2_slod4_tg.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ss1_lod_slod3.png b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ss1_lod_slod3.png new file mode 100644 index 0000000..92cbe66 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/map-gta5/textures/ss1_lod_slod3.png differ diff --git a/OpenGLEngine/OpenGLEngine/RigidBodyComponent.h b/OpenGLEngine/OpenGLEngine/RigidBodyComponent.h index f391a16..b2b56d5 100644 --- a/OpenGLEngine/OpenGLEngine/RigidBodyComponent.h +++ b/OpenGLEngine/OpenGLEngine/RigidBodyComponent.h @@ -3,74 +3,17 @@ namespace Reality { - struct RigidBodyComponent + struct RigidbodyComponent { - RigidBodyComponent(float mass = 1.0f, float _linearDamping = 0.4f, float _angularDamping = 0.3f, Vector3 _velocity = Vector3(0, 0, 0), Vector3 _angularVelocity = Vector3(0, 0, 0), float _gravityScale = 1) - : inverseMass(1.0f / mass), velocity(_velocity), angularVelocity(_angularVelocity), linearDamping(_linearDamping), angularDamping(_angularDamping), gravityScale(_gravityScale), rp3dId(-1) + RigidbodyComponent(Vector3 _velocity = Vector3(0, 0, 0), Vector3 _angularVelocity = Vector3(0, 0, 0)) + :velocity(_velocity), acceleration(Vector3(0, 0, 0)), + angularVelocity(_angularVelocity), angularAcceleration(Vector3(0, 0, 0)) { - inertiaTensor = glm::mat3(0.0f); - inertiaTensor[0][0] = 0.001f; - inertiaTensor[1][1] = 0.001f; - inertiaTensor[2][2] = 0.001f; - accelaration = Vector3(0, 0, 0); - angularAccelaration = Vector3(0, 0, 0); - forceAccumulator = Vector3(0, 0, 0); - torqueAccumulator = Vector3(0, 0, 0); + } - float inverseMass; + Vector3 acceleration; Vector3 velocity; + Vector3 angularAcceleration; Vector3 angularVelocity; - Vector3 accelaration; - Vector3 angularAccelaration; - Mat3 inertiaTensor; - float gravityScale; - float linearDamping; - float angularDamping; - int rp3dId; - - Mat3 worldInverseInertiaTensor(Mat3 localToWorld) - { - Mat3 worldInertiaTensor = localToWorld * inertiaTensor * glm::inverse(localToWorld); - return glm::inverse(worldInertiaTensor); - } - - - // Forces - inline void AddForce(Vector3 force) - { - forceAccumulator += force; - } - inline Vector3 GetForce() - { - return forceAccumulator; - } - inline void ResetForceAccumulator() - { - forceAccumulator = Vector3(0, 0, 0); - } - - // Torque and force - inline void AddForceAtPoint(Vector3 force, Vector3 point, Vector3 origin) - { - AddForce(force); - AddTorque(glm::cross(point - origin, force)); - } - - // Torque - inline void AddTorque(Vector3 torque) - { - torqueAccumulator += torque; - } - inline Vector3 GetTorque() - { - return torqueAccumulator; - } - inline void ResetTorqueAccumulator() - { - torqueAccumulator = Vector3(0, 0, 0); - } - private: - Vector3 forceAccumulator; - Vector3 torqueAccumulator; }; } diff --git a/OpenGLEngine/OpenGLEngine/RigidBodySystem.cpp b/OpenGLEngine/OpenGLEngine/RigidBodySystem.cpp index aa20197..b8b36d3 100644 --- a/OpenGLEngine/OpenGLEngine/RigidBodySystem.cpp +++ b/OpenGLEngine/OpenGLEngine/RigidBodySystem.cpp @@ -1,77 +1,26 @@ -#include "RigidBodySystem.h" -#include "RigidBodyData.h" +#include "RigidbodySystem.h" namespace Reality { - RigidBodySystem::RigidBodySystem(rp3d::CollisionWorld& _rp3dWorld) - :rp3dWorld(_rp3dWorld) + RigidbodySystem::RigidbodySystem() { requireComponent(); - requireComponent(); + requireComponent(); } - void RigidBodySystem::Update(float deltaTime) + void RigidbodySystem::Update(float deltaTime) { - std::vector rp3dBodiesTemp; - std::vector aliveIds; - aliveIds.resize(rp3dBodies.size()); - int id = 0; - for (auto e : getEntities()) { - auto &rigidbody = e.getComponent(); - auto &transform = e.getComponent(); - - // Update RP3D Ids - // Calculate rp3d transform - rp3d::Vector3 initPosition(transform.GetPosition().x, - transform.GetPosition().y, - transform.GetPosition().z); - Quaternion quat = transform.GetOrientation(); - rp3d::Quaternion initOrientation = rp3d::Quaternion( - quat.x, quat.y, quat.z, quat.w); - rp3d::Transform rp3dtransform(initPosition, initOrientation); - // If new rigidbody, create an entry - if (rigidbody.rp3dId < 0) - { - rp3d::CollisionBody * body = rp3dWorld.createCollisionBody(rp3dtransform); - RigidBodyData* data = new RigidBodyData(e); - body->setUserData(data); - rp3dBodiesTemp.push_back(body); - rigidbody.rp3dId = id; - } - else - { - rp3d::CollisionBody * body = rp3dBodies[rigidbody.rp3dId]; - body->setTransform(rp3dtransform); - aliveIds[rigidbody.rp3dId] = 1; - rp3dBodiesTemp.push_back(body); - rigidbody.rp3dId = id; - } - id++; - - // Update velocity from accelarartion - rigidbody.velocity += rigidbody.accelaration * deltaTime; - rigidbody.angularVelocity += rigidbody.angularAccelaration * deltaTime; + auto& transform = e.getComponent(); + auto& rigidbody = e.getComponent(); - // Damping - rigidbody.velocity *= pow(1.0f - rigidbody.linearDamping, deltaTime); - rigidbody.angularVelocity *= pow(1.0f - rigidbody.angularDamping, deltaTime); - + rigidbody.velocity += rigidbody.acceleration * deltaTime; transform.SetPosition(transform.GetPosition() + rigidbody.velocity * deltaTime); - glm::quat angularVelocityQuat = glm::quat(0, rigidbody.angularVelocity.x, rigidbody.angularVelocity.y, rigidbody.angularVelocity.z); - getWorld().data.renderUtil->DrawLine(transform.GetPosition(), transform.GetPosition() + rigidbody.angularVelocity, Color::Blue); - transform.SetOrientation(glm::normalize(transform.GetOrientation() + 0.5f * angularVelocityQuat * transform.GetOrientation() * deltaTime)); - } - for (int i = 0; i < aliveIds.size(); i++) - { - if (aliveIds[i] == 0) - { - rp3dWorld.destroyCollisionBody(rp3dBodies[i]); - } + rigidbody.angularVelocity += rigidbody.angularAcceleration * deltaTime; + Quaternion deltaRot = Quaternion(0, rigidbody.angularVelocity * deltaTime); + transform.SetOrientation(glm::normalize(transform.GetOrientation() + 0.5f * deltaRot * transform.GetOrientation())); } - - rp3dBodies = rp3dBodiesTemp; } } diff --git a/OpenGLEngine/OpenGLEngine/RigidBodySystem.h b/OpenGLEngine/OpenGLEngine/RigidBodySystem.h index 88b8e03..7d3800c 100644 --- a/OpenGLEngine/OpenGLEngine/RigidBodySystem.h +++ b/OpenGLEngine/OpenGLEngine/RigidBodySystem.h @@ -1,17 +1,14 @@ #pragma once #include "ECSConfig.h" -#include "RigidBodyComponent.h" #include "TransformComponentV2.h" -#include +#include "RigidbodyComponent.h" namespace Reality { - class RigidBodySystem : public ECSSystem + class RigidbodySystem : public ECSSystem { public: - RigidBodySystem(rp3d::CollisionWorld& _rp3dWorld); + RigidbodySystem(); void Update(float deltaTime); - rp3d::CollisionWorld& rp3dWorld; - std::vector rp3dBodies; }; } diff --git a/OpenGLEngine/OpenGLEngine/RodComponent.h b/OpenGLEngine/OpenGLEngine/RodComponent.h index 33583ad..5c5b3ef 100644 --- a/OpenGLEngine/OpenGLEngine/RodComponent.h +++ b/OpenGLEngine/OpenGLEngine/RodComponent.h @@ -5,11 +5,17 @@ namespace Reality { struct RodComponent { - RodComponent(ECSEntity a = ECSEntity(), ECSEntity b = ECSEntity(), float _length = 10) - : entityA(a), entityB(b), length(_length) - {} + RodComponent(ECSEntity a = ECSEntity(), + ECSEntity b = ECSEntity(), + float _rodLength = 10) + : entityA(a), + entityB(b), + rodLength(_rodLength) + { + + } ECSEntity entityA; ECSEntity entityB; - float length; + float rodLength; }; } diff --git a/OpenGLEngine/OpenGLEngine/RodSystem.cpp b/OpenGLEngine/OpenGLEngine/RodSystem.cpp index f1da27e..c3f6bb7 100644 --- a/OpenGLEngine/OpenGLEngine/RodSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/RodSystem.cpp @@ -1,6 +1,6 @@ #include "RodSystem.h" #include "TransformComponent.h" -#include "ParticleContactComponent.h" +#include "ParticleContactEvent.h" namespace Reality { @@ -14,49 +14,50 @@ namespace Reality for (auto e : getEntities()) { auto& rod = e.getComponent(); - float currentLength = glm::length(rod.entityA.getComponent().position - - rod.entityB.getComponent().position); - getWorld().data.renderUtil->DrawSphere(rod.entityA.getComponent().position, 1, Color::Purple); - getWorld().data.renderUtil->DrawSphere(rod.entityB.getComponent().position, 1, Color::Purple); - - if (currentLength == rod.length) + if (rod.entityA.hasComponent() && + rod.entityB.hasComponent()) { - continue; + auto& transformA = rod.entityA.getComponent(); + auto& transformB = rod.entityB.getComponent(); + + Vector3 relativePos = transformA.position - transformB.position; + float length = glm::length(relativePos); + + if (length > rod.rodLength) + { + Vector3 normal = -glm::normalize(relativePos); + float penetration = length - rod.rodLength; + + getWorld().getEventManager().emitEvent( + rod.entityA, + rod.entityB, + 0, + normal, + penetration + ); + } + + if (length < rod.rodLength) + { + Vector3 normal = glm::normalize(relativePos); + float penetration = rod.rodLength - length; + + getWorld().getEventManager().emitEvent( + rod.entityA, + rod.entityB, + 0, + normal, + penetration + ); + } + + getWorld().data.renderUtil->DrawLine( + transformA.position, + transformB.position, + Color::Beige + ); } - - Vector3 normal = glm::normalize(rod.entityB.getComponent().position - - rod.entityA.getComponent().position); - - - if (currentLength > rod.length) - { - auto contactEntity = getWorld().createEntity(); - contactEntity.addComponent( - rod.entityA, - rod.entityB, - 0, - normal, - currentLength - rod.length); - getWorld().data.renderUtil->DrawLine(rod.entityA.getComponent().position, - rod.entityB.getComponent().position, - Color::Yellow); - } - else - { - auto contactEntity = getWorld().createEntity(); - contactEntity.addComponent( - rod.entityA, - rod.entityB, - 0, - -normal, - rod.length - currentLength); - getWorld().data.renderUtil->DrawLine(rod.entityA.getComponent().position, - rod.entityB.getComponent().position, - Color::Yellow); - } - - } } } diff --git a/OpenGLEngine/OpenGLEngine/RotateComponent.h b/OpenGLEngine/OpenGLEngine/RotateComponent.h index ecc5968..bde45b6 100644 --- a/OpenGLEngine/OpenGLEngine/RotateComponent.h +++ b/OpenGLEngine/OpenGLEngine/RotateComponent.h @@ -1,9 +1,15 @@ #pragma once -struct RotateComponent +#include "ECSConfig.h" + +namespace Reality { - float xRot; - float yRot; - float zRot; - RotateComponent(float x = 0, float y = 0, float z = 0) - : xRot(x), yRot(y), zRot(z) {} -}; + struct RotateComponent + { + RotateComponent(Vector3 _rotationVelocity = Vector3(0, 0, 0)) + : rotationVelocity(_rotationVelocity) + { + + } + Vector3 rotationVelocity; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/RotateComponentV2.h b/OpenGLEngine/OpenGLEngine/RotateComponentV2.h new file mode 100644 index 0000000..b5f34d8 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/RotateComponentV2.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct RotateComponentV2 + { + RotateComponentV2(Vector3 _rotationVelocity = Vector3(0, 0, 0)) + : rotationVelocity(_rotationVelocity) + { + + } + Vector3 rotationVelocity; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/RotateSystem.cpp b/OpenGLEngine/OpenGLEngine/RotateSystem.cpp index 6bd16a0..2fa5ae1 100644 --- a/OpenGLEngine/OpenGLEngine/RotateSystem.cpp +++ b/OpenGLEngine/OpenGLEngine/RotateSystem.cpp @@ -1,20 +1,45 @@ #include "RotateSystem.h" +#include "LifeTimeComponent.h" +#include "TransformComponentV2.h" -RotateSystem::RotateSystem() +namespace Reality { - requireComponent(); - requireComponent(); -} + RotateSystem::RotateSystem() + { + requireComponent(); + requireComponent(); + } -void RotateSystem::Update(float deltaTime) -{ - for (auto e : getEntities()) + void RotateSystem::Update(float deltaTime) { - auto &rotate = e.getComponent(); - auto &transform = e.getComponent(); + timer += deltaTime; + for (auto e : getEntities()) + { + auto& transform = e.getComponent(); + auto& rotate = e.getComponent(); + + transform.eulerAngles += rotate.rotationVelocity * deltaTime; + + if (timer >= 0.1f) + { + auto e1 = getWorld().createEntity(); + e1.addComponent(transform.position + transform.Up() * 10.0f); + e1.addComponent(); + + auto e2 = getWorld().createEntity(); + e2.addComponent(transform.position + transform.Right() * 10.0f); + e2.addComponent(5, Color::Red); + + auto e3 = getWorld().createEntity(); + e3.addComponent(transform.position + transform.Forward() * 10.0f); + e3.addComponent(5, Color::Blue); + } + } + if (timer >= 0.1f) + { + timer = 0; + } - transform.eulerAngles.x += rotate.xRot * deltaTime; - transform.eulerAngles.y += rotate.yRot * deltaTime; - transform.eulerAngles.z += rotate.zRot * deltaTime; + //getWorld().data.renderUtil->RenderText("Euler Angles", 350, 200, 1, Color::Orange); } } diff --git a/OpenGLEngine/OpenGLEngine/RotateSystem.h b/OpenGLEngine/OpenGLEngine/RotateSystem.h index 1a9cc29..c76bcef 100644 --- a/OpenGLEngine/OpenGLEngine/RotateSystem.h +++ b/OpenGLEngine/OpenGLEngine/RotateSystem.h @@ -3,11 +3,14 @@ #include "TransformComponent.h" #include "RotateComponent.h" -using namespace Reality; -class RotateSystem : public ECSSystem +namespace Reality { -public: - RotateSystem(); - void Update(float deltaTime); -}; - + class RotateSystem : public ECSSystem + { + public: + RotateSystem(); + void Update(float deltaTime); + private: + float timer = 0; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/RotateSystemV2.cpp b/OpenGLEngine/OpenGLEngine/RotateSystemV2.cpp new file mode 100644 index 0000000..b3d64fe --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/RotateSystemV2.cpp @@ -0,0 +1,51 @@ +#include "RotateSystemV2.h" +#include +#include "LifeTimeComponent.h" + +namespace Reality +{ + RotateSystemV2::RotateSystemV2() + { + requireComponent(); + requireComponent(); + } + + void RotateSystemV2::Update(float deltaTime) + { + timer += deltaTime; + for (auto e : getEntities()) + { + auto& transform = e.getComponent(); + auto& rotate = e.getComponent(); + + Vector3 axis = glm::normalize(rotate.rotationVelocity); + float angle = glm::radians(glm::length(rotate.rotationVelocity)) * deltaTime; + + Quaternion deltaQuat = glm::angleAxis(angle, axis); + Quaternion newRot = glm::normalize(deltaQuat * transform.GetOrientation()); + + transform.SetOrientation(newRot); + + if (timer >= 0.1f) + { + auto e1 = getWorld().createEntity(); + e1.addComponent(transform.GetPosition() + transform.Up() * 10.0f); + e1.addComponent(); + + auto e2 = getWorld().createEntity(); + e2.addComponent(transform.GetPosition() + transform.Right() * 10.0f); + e2.addComponent(5, Color::Red); + + auto e3 = getWorld().createEntity(); + e3.addComponent(transform.GetPosition() + transform.Forward() * 10.0f); + e3.addComponent(5, Color::Blue); + } + } + if (timer >= 0.1f) + { + timer = 0; + } + + //getWorld().data.renderUtil->RenderText("Quaternions", 1300, 200, 1, Color::Orange); + } +} diff --git a/OpenGLEngine/OpenGLEngine/RotateSystemV2.h b/OpenGLEngine/OpenGLEngine/RotateSystemV2.h new file mode 100644 index 0000000..9b594bf --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/RotateSystemV2.h @@ -0,0 +1,16 @@ +#pragma once +#include "ECSConfig.h" +#include "TransformComponentV2.h" +#include "RotateComponentV2.h" + +namespace Reality +{ + class RotateSystemV2 : public ECSSystem + { + public: + RotateSystemV2(); + void Update(float deltaTime); + private: + float timer = 0; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ThrusterComponent.h b/OpenGLEngine/OpenGLEngine/ThrusterComponent.h new file mode 100644 index 0000000..c52e34d --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ThrusterComponent.h @@ -0,0 +1,22 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct ThrusterComponent + { + ThrusterComponent(ECSEntity _targetEntity = ECSEntity(), + Vector3 _localThrustDirection = Vector3(0, 0, 1), + float _thrust = 200) + :targetEntity(_targetEntity), + localThrustDirection(_localThrustDirection), + thrust(_thrust) + { + + } + ECSEntity targetEntity; + Vector3 localThrustDirection; + float thrust; + float timer = 0; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/ThrusterSystem.cpp b/OpenGLEngine/OpenGLEngine/ThrusterSystem.cpp new file mode 100644 index 0000000..765dea5 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ThrusterSystem.cpp @@ -0,0 +1,43 @@ +#include "ThrusterSystem.h" +#include "TransformComponentV2.h" +#include "ForceAndTorqueAccumulatorComponent.h" +#include "LifeTimeComponent.h" + +namespace Reality +{ + ThrusterSystem::ThrusterSystem() + { + requireComponent(); + } + + void ThrusterSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& thruster = e.getComponent(); + + if (thruster.targetEntity.hasComponent() && + thruster.targetEntity.hasComponent()) + { + auto& transform = thruster.targetEntity.getComponent(); + auto& forceAndTorque = thruster.targetEntity.getComponent(); + + if (glfwGetKey(getWorld().data.renderUtil->window->glfwWindow, GLFW_KEY_W) == GLFW_PRESS) + { + Vector3 worldThrustDirection = transform.LocalToWorldDirection(thruster.localThrustDirection); + forceAndTorque.AddForce(worldThrustDirection * thruster.thrust); + + thruster.timer += deltaTime; + + if (thruster.timer > 0.3f) + { + auto smokeTrail = getWorld().createEntity(); + smokeTrail.addComponent(transform.GetPosition() - worldThrustDirection * 10.0f); + smokeTrail.addComponent(); + thruster.timer = 0; + } + } + } + } + } +} diff --git a/OpenGLEngine/OpenGLEngine/ThrusterSystem.h b/OpenGLEngine/OpenGLEngine/ThrusterSystem.h new file mode 100644 index 0000000..d32164d --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ThrusterSystem.h @@ -0,0 +1,13 @@ +#pragma once +#include "ECSConfig.h" +#include "ThrusterComponent.h" + +namespace Reality +{ + class ThrusterSystem : public ECSSystem + { + public: + ThrusterSystem(); + void Update(float deltaTime); + }; +} diff --git a/OpenGLEngine/OpenGLEngine/TransformComponent.h b/OpenGLEngine/OpenGLEngine/TransformComponent.h index cfa71b5..a5bb70f 100644 --- a/OpenGLEngine/OpenGLEngine/TransformComponent.h +++ b/OpenGLEngine/OpenGLEngine/TransformComponent.h @@ -12,11 +12,26 @@ namespace Reality Vector3 position; Vector3 scale; Vector3 eulerAngles; - Quaternion orientation; - Mat4 scaleMatrix; - Mat4 rotationMatrix; - Mat4 translationMatrix; - Mat4 unScaledTransformationMatrix; - Mat4 transformationMatrix; + + inline const Vector3& Right() + { + Vector3 radAngle = Vector3(glm::radians(eulerAngles.x), + glm::radians(eulerAngles.y), glm::radians(eulerAngles.z)); + return glm::quat(radAngle) * Vector3(1, 0, 0); + } + + inline const Vector3& Up() + { + Vector3 radAngle = Vector3(glm::radians(eulerAngles.x), + glm::radians(eulerAngles.y), glm::radians(eulerAngles.z)); + return glm::quat(radAngle) * Vector3(0, 1, 0); + } + + inline const Vector3& Forward() + { + Vector3 radAngle = Vector3(glm::radians(eulerAngles.x), + glm::radians(eulerAngles.y), glm::radians(eulerAngles.z)); + return glm::quat(radAngle) * Vector3(0, 0, 1); + } }; } \ No newline at end of file diff --git a/OpenGLEngine/OpenGLEngine/TransformComponentV2.h b/OpenGLEngine/OpenGLEngine/TransformComponentV2.h index 27575d5..b3bfc0e 100644 --- a/OpenGLEngine/OpenGLEngine/TransformComponentV2.h +++ b/OpenGLEngine/OpenGLEngine/TransformComponentV2.h @@ -6,10 +6,10 @@ namespace Reality { struct TransformComponentV2 { - TransformComponentV2(Vector3 _position = Vector3(0, 0, 0), Vector3 _scale = Vector3(1, 1, 1), Vector3 _eulerAngles = Vector3(0.0f, 0.0f, 0.0f)) : + TransformComponentV2(Vector3 _position = Vector3(0, 0, 0), Vector3 _scale = Vector3(1, 1, 1), Vector3 _eulerAngles = Vector3(0, 0, 0)) : position(_position), scale(_scale) { - SetRotation(_eulerAngles); + SetEulerAngles(_eulerAngles); } private: Vector3 position; @@ -24,22 +24,25 @@ namespace Reality inline void UpdateMatrices() { - scaleMatrix = glm::scale(glm::mat4(1.0f), scale); - translationMatrix = glm::translate(glm::mat4(1.0f), position); + scaleMatrix = glm::scale(Mat4(1.0f), scale); rotationMatrix = glm::toMat4(orientation); + translationMatrix = glm::translate(Mat4(1.0f), position); unScaledTransformationMatrix = translationMatrix * rotationMatrix; transformationMatrix = unScaledTransformationMatrix * scaleMatrix; dirty = false; } + public: - public: inline void SetPosition(const Vector3& _position) { position = _position; dirty = true; } - inline Vector3 GetPosition() { return position; } + inline const Vector3& GetPosition() + { + return position; + } inline void SetScale(const Vector3& _scale) { @@ -47,43 +50,36 @@ namespace Reality dirty = true; } - inline Vector3 GetScale() { return scale; } - - inline void SetOrientation(const Quaternion& _orientation) + inline const Vector3& GetScale() { - orientation = _orientation; - dirty = true; + return scale; } - inline Quaternion GetOrientation() { return orientation; } - - // Euler angles in degrees - inline void SetRotation(Vector3 eulerAngles) + inline void SetOrientation(const Quaternion& _orientation) { - glm::vec3 rotationInRads = glm::vec3(glm::radians(eulerAngles.x), - glm::radians(eulerAngles.y), glm::radians(eulerAngles.z)); - orientation = glm::quat(rotationInRads); + orientation = _orientation; dirty = true; } - inline Vector3 GetRotation() { return glm::eulerAngles(orientation); } - - inline Vector3 Up() + inline const Quaternion& GetOrientation() { - return orientation * Vector3(0.0f, 1.0f, 0.0f); + return orientation; } - inline Vector3 Right() + inline void SetEulerAngles(const Vector3& _eulerAngles) { - return orientation * Vector3(1.0f, 0.0f, 0.0f); + Vector3 radAngle = Vector3(glm::radians(_eulerAngles.x), + glm::radians(_eulerAngles.y), glm::radians(_eulerAngles.z)); + orientation = glm::quat(radAngle); + dirty = true; } - inline Vector3 Forward() + inline const Vector3& GetEulerAngles() { - return orientation * Vector3(0.0f, 0.0f, 1.0f); + return glm::eulerAngles(orientation); } - inline Mat4 GetScaleMatrix() + inline const Mat4& GetScaleMatrix() { if (dirty) { @@ -92,7 +88,7 @@ namespace Reality return scaleMatrix; } - inline Mat4 GetRotationMatrix() + inline const Mat4& GetRotationMatrix() { if (dirty) { @@ -101,16 +97,16 @@ namespace Reality return rotationMatrix; } - inline Mat4 GetTranslationMatrix() + inline const Mat4& GetTranslationMatrix() { if (dirty) { UpdateMatrices(); } - return transformationMatrix; + return translationMatrix; } - inline Mat4 GetUnScaledTransformationMatrix() + inline const Mat4& GetUnScaledTransformationMatrix() { if (dirty) { @@ -119,7 +115,7 @@ namespace Reality return unScaledTransformationMatrix; } - inline Mat4 GetTransformationMatrix() + inline const Mat4& GetTransformationMatrix() { if (dirty) { @@ -128,30 +124,48 @@ namespace Reality return transformationMatrix; } - inline Vector3 WorldToLocalPosition(Vector3 _position) + inline const Vector3& Right() { - return glm::inverse(GetTransformationMatrix()) * Vector4(_position, 1); + return orientation * Vector3(1, 0, 0); + } + + inline const Vector3& Up() + { + return orientation * Vector3(0, 1, 0); + } + inline const Vector3& Forward() + { + return orientation * Vector3(0, 0, 1); } - inline Vector3 LocalToWorldPosition(Vector3 _position) + inline const Vector3& LocalToWorldDirection(const Vector3& _localDirection) { - return GetTransformationMatrix() * Vector4(_position, 1); + return orientation * _localDirection; } - //TODO : Check - inline Vector3 WorldToLocalDirection(Vector3 direction) + inline const Vector3& WorldToLocalDirection(const Vector3& _worldDirection) { if (glm::length(orientation) > 0) { - return glm::inverse(orientation) * direction; + return glm::inverse(orientation) * _worldDirection; } return Vector3(0, 0, 0); } - inline Vector3 LocalToWorldDirection(Vector3 direction) + + inline const Vector3& LocalToWorldPosition(const Vector3& _localPosition) + { + return GetTransformationMatrix() * Vector4(_localPosition, 1.0f); + } + + inline const Vector3& WorldToLocalPosition(const Vector3& _worldPosition) { - return orientation * direction; + if (abs(glm::determinant(GetTransformationMatrix())) > 0) + { + return glm::inverse(GetTransformationMatrix()) * Vector4(_worldPosition, 1.0f); + } + return Vector3(0, 0, 0); } }; }