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/BuoyancyCenter2Component.h b/OpenGLEngine/OpenGLEngine/BuoyancyCenter2Component.h new file mode 100644 index 0000000..88b6007 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancyCenter2Component.h @@ -0,0 +1,18 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct BuoyancyCenter2Component + { + BuoyancyCenter2Component(Vector3 _positionOffset = Vector3(0,0,0), float _maxDepth = 1.0f, float _volume = 1.0f) + : positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume) + { + + } + + Vector3 positionOffset; + float maxDepth; + float volume; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/BuoyancyCenter3Component.h b/OpenGLEngine/OpenGLEngine/BuoyancyCenter3Component.h new file mode 100644 index 0000000..7212a68 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancyCenter3Component.h @@ -0,0 +1,18 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct BuoyancyCenter3Component + { + BuoyancyCenter3Component(Vector3 _positionOffset = Vector3(0, 0, 0), float _maxDepth = 1.0f, float _volume = 1.0f) + : positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume) + { + + } + + Vector3 positionOffset; + float maxDepth; + float volume; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/BuoyancyCenter4Component.h b/OpenGLEngine/OpenGLEngine/BuoyancyCenter4Component.h new file mode 100644 index 0000000..2f71486 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancyCenter4Component.h @@ -0,0 +1,18 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct BuoyancyCenter4Component + { + BuoyancyCenter4Component(Vector3 _positionOffset = Vector3(0, 0, 0), float _maxDepth = 1.0f, float _volume = 1.0f) + : positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume) + { + + } + + Vector3 positionOffset; + float maxDepth; + float volume; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/BuoyancyCenterComponent.h b/OpenGLEngine/OpenGLEngine/BuoyancyCenterComponent.h new file mode 100644 index 0000000..2c4dbc0 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/BuoyancyCenterComponent.h @@ -0,0 +1,18 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct BuoyancyCenterComponent + { + BuoyancyCenterComponent(Vector3 _positionOffset = Vector3(0, 0, 0), float _maxDepth = 1.0f, float _volume = 1.0f) + : positionOffset(_positionOffset), maxDepth(_maxDepth), volume(_volume) + { + + } + + Vector3 positionOffset; + float maxDepth; + float volume; + }; +} 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..09ad65b --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/GravityForceComponent.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct GravityForceComponent + { + GravityForceComponent(float _gravityScale = 1.0f) + : gravityScale(_gravityScale) + { + + } + float gravityScale; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/GravityForceSystem.cpp b/OpenGLEngine/OpenGLEngine/GravityForceSystem.cpp new file mode 100644 index 0000000..c9b1dc5 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/GravityForceSystem.cpp @@ -0,0 +1,39 @@ +#include "GravityForceSystem.h" +#include "ForceAndTorqueAccumulatorComponent.h" + +namespace Reality +{ + GravityForceSystem::GravityForceSystem() + { + //requireComponent(); + requireComponent(); + } + + void GravityForceSystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + if (e.hasComponent()) + { + + auto& forceAcc = e.getComponent(); + auto& gravity = e.getComponent(); + + if (forceAcc.inverseMass > 0) + { + forceAcc.AddForce(worldGravity * gravity.gravityScale / forceAcc.inverseMass); + } + } + else if (e.hasComponent()) + { + 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..850e359 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/GravityForceSystem.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" +#include "ForceAccumulatorComponent.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..7c3b27a 100644 --- a/OpenGLEngine/OpenGLEngine/Main.cpp +++ b/OpenGLEngine/OpenGLEngine/Main.cpp @@ -1,60 +1,59 @@ -//#define STB_IMAGE_IMPLEMENTATION -#include "UpdateTransformMatricesSystem.h" +// Team Members : Brian Viveiros 101209942, Emmanuel Nofuente-Loblack 101126071 + #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 "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 +#include "BuoyancyCenterComponent.h" +#include "BuoyancyCenter2Component.h" +#include "NewBuoyancySystem.h" +#include "NewBuoyancy2System.h" + + +#include "BuoyancyCenter3Component.h" +#include "BuoyancyCenter4Component.h" +#include "NewBuoyancy3System.h" +#include "NewBuoyancy4System.h" using namespace Reality; void LoadShaders(ECSWorld& world); void LoadModels(ECSWorld& world); -void MakeABunchaObjects(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 MakeABoatSimulator(ECSWorld& world); + + int main() { ECSWorld world; @@ -63,7 +62,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,62 +70,44 @@ 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); - //MakeABunchaSprings(world); - //MakeACable(world); - //akeCablesAndRods(world); - //MakeFlight(world); - //TestContacts(world); - TestCollision(world); + MakeABoatSimulator(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(); - - // 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(); - + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); + world.getSystemManager().addSystem(); float time = glfwGetTime(); float stepTime = glfwGetTime(); @@ -171,49 +152,56 @@ 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); - // 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); + // Physics + 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); + /// Rigidbody + 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); + + 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 + + world.data.renderUtil->DrawCube(Vector3(0, 0, 0), Vector3(0, 0, 0)); + world.getSystemManager().getSystem().Update(deltaTime); world.getSystemManager().getSystem().Update(deltaTime); world.getSystemManager().getSystem().Update(deltaTime); @@ -239,7 +227,6 @@ int main() std::string debugString = logic < 10 ? " " + std::to_string(debug) : std::to_string(debug); world.data.renderUtil->RenderText("Logic : " + logicString + "%" + - //+ " | Physics : " + std::to_string((int)round(physicsDelta * 100.0f / deltaTime)) + "%" + + " | Rendering : " + renderString + "%" + + " | Debug : " + debugString + "%" , 1680.0f, 1040.0f, 0.25f, Color(0, 1, 1, 1)); @@ -259,12 +246,9 @@ int main() world.data.renderUtil->SwapBuffers(world.data.renderUtil->window->glfwWindow); - // Show FPS in console - //std::cout << "FPS : " << 1.0f / deltaTime << std::endl; } - // glfw: terminate, clearing all previously allocated GLFW resources. - // ------------------------------------------------------------------ + glfwTerminate(); return 0; } @@ -276,365 +260,97 @@ 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"}}) - }); -} - -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)); - // Add mesh - e.addComponent("Resources/Models/supermarine-spitfire/spitfire.fbx"); - e.addComponent(0, 40, 0); - - 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) -{ - 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); - - 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"); - - auto springEntinty2 = world.createEntity(); - springEntinty2.addComponent(Vector3(2.5f, 0 + yOffset, 1)); - springEntinty2.addComponent(5, 5, e2); - - 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"); - - 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) -{ - for (int i = 0; i < 30; 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 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 MakeACable(ECSWorld& world) -{ - auto e1 = world.createEntity(); - e1.addComponent(Vector3(0, 40, 0)); - //e1.addComponent(1, Vector3(0,0,0), 0); - - auto e2 = world.createEntity(); - e2.addComponent(Vector3(0, 30, 0)); - e2.addComponent(1); - - auto e = world.createEntity(); - e.addComponent(e1, e2, 20); -} -void MakeCablesAndRods(ECSWorld& world) -{ - auto eFixed = world.createEntity(); - eFixed.addComponent(Vector3(10, 40, 0)); - //e1.addComponent(1, Vector3(0,0,0), 0); - - auto eFixed2 = world.createEntity(); - eFixed2.addComponent(Vector3(20, 10, 0)); - - auto eFixed3 = world.createEntity(); - eFixed3.addComponent(Vector3(-20, 10, 0)); - - 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); - - auto e3 = world.createEntity(); - e3.addComponent(Vector3(0, 10, 0)); - e3.addComponent(10); - - 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); -} - -void MakeFlight(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)); - // 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)); - - auto buildingL = world.createEntity(); - buildingL.addComponent(Vector3(-100.0f, 0.0f, 50.0f * i)); - buildingL.addComponent(RANDOM_FLOAT(100.0f, 500.0f)); - } -} - -void TestContacts(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); - }*/ + ModelData("Resources/Models/Boats/19287_Bass_boat_v1.obj", + {{"Blank.mtl"}}), + ModelData("Resources/Models/water/water.fbx", + {{"water-texture.jpg"}}) + }); } -void TestCollision(ECSWorld& world) +void MakeABoatSimulator(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 water = world.createEntity(); + water.addComponent("Resources/Models/water/water.fbx", Vector3(-90, 0, 0), Vector3(0, -10, 0)); + water.addComponent(); + + auto boat = world.createEntity(); + + boat.addComponent(); + boat.addComponent(Vector3(0.0f, -10.0f, 100.0f), 5.0f, 1.0f); + boat.addComponent(Vector3(0.0f, -10.0f, -100.0f), 5.0f, 1.0f); + boat.addComponent(Vector3(80.0f, -10.0f, 0.0f), 5.0f, 1.0f); + boat.addComponent(Vector3(-80.0f, -10.0f, 0.0f), 5.0f, 1.0f); + boat.addComponent(); + + boat.addComponent(Vector3(0, 20, -50), Vector3(0.1f, 0.1f, 0.1f), Vector3(-20, 180, 10)); + boat.addComponent("Resources/Models/Boats/19287_Bass_boat_v1.obj", Vector3(-90, 0, 0), Vector3(0, -100, 0)); + + boat.addComponent(1.0f); + + auto engine = world.createEntity(); + engine.addComponent(boat); + + auto rudder = world.createEntity(); + rudder.addComponent(); + rudder.addComponent(boat, Vector3(0, 0, 0), Vector3(0, -200, -100)); + std::vector rudderWingPositiveKeys = { GLFW_KEY_D }; + std::vector rudderWingNegetiveKeys = { GLFW_KEY_A }; + rudder.addComponent( + Vector3(-0.4f, 0, 0), + Vector3(0.4f, 0, 0), + rudderWingPositiveKeys, rudderWingNegetiveKeys); + boat.addComponent(); + + boat.addComponent(); } 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 +361,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..e55df7a 100644 --- a/OpenGLEngine/OpenGLEngine/Mix/System.h +++ b/OpenGLEngine/OpenGLEngine/Mix/System.h @@ -126,7 +126,7 @@ template T& SystemManager::getSystem() { if (!hasSystem()) { - throw std::runtime_error(std::string("Failed to get system: ") + typeid(T).name()); + //throw std::runtime_error(std::string("Failed to get system: ") + typeid(T).name()); } auto it = systems.find(std::type_index(typeid(T))); diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancy2System.cpp b/OpenGLEngine/OpenGLEngine/NewBuoyancy2System.cpp new file mode 100644 index 0000000..9b35e69 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancy2System.cpp @@ -0,0 +1,54 @@ +#include "NewBuoyancy2System.h" +#include "BuoyancyCenter2Component.h" +#include "RigidBodyComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" +#include "TransformComponentV2.h" + +namespace Reality +{ + NewBuoyancy2System::NewBuoyancy2System() + { + requireComponent(); + requireComponent(); + requireComponent(); + requireComponent(); + } + + void NewBuoyancy2System::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& buoy = e.getComponent(); + auto& rigidbody = e.getComponent(); + auto& transform = e.getComponent(); + auto& accumulator = e.getComponent(); + + Vector3 buoyPosition = transform.LocalToWorldPosition(buoy.positionOffset); + + Vector3 offset = buoy.positionOffset; + + float pitch = transform.GetEulerAngles().x; + + float length = buoy.positionOffset.length(); + + + + + if (buoyPosition.y < 0.0f) + { + float depth = buoyPosition.y; + + Vector3 force = Vector3(0.0f, UpForce(depth, buoy.volume), 0.0f); + + accumulator.AddForceAtPoint(force, buoyPosition, transform.GetPosition()); + + getWorld().data.renderUtil->DrawCube(buoyPosition, Vector3(1, 1, 1)); + } + } + } + + float NewBuoyancy2System::UpForce(float depth, float vol) + { + return (liquidDensity * vol * abs(depth) * 0.1f); + } +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancy2System.h b/OpenGLEngine/OpenGLEngine/NewBuoyancy2System.h new file mode 100644 index 0000000..4bcf587 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancy2System.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + class NewBuoyancy2System : public ECSSystem + { + public: + NewBuoyancy2System(); + void Update(float deltaTime); + float UpForce(float depth, float vol); + float liquidDensity = 10.5f; + float waterLevel = 0.0f; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancy3System.cpp b/OpenGLEngine/OpenGLEngine/NewBuoyancy3System.cpp new file mode 100644 index 0000000..f70d852 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancy3System.cpp @@ -0,0 +1,54 @@ +#include "NewBuoyancy3System.h" +#include "BuoyancyCenter3Component.h" +#include "RigidBodyComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" +#include "TransformComponentV2.h" + +namespace Reality +{ + NewBuoyancy3System::NewBuoyancy3System() + { + requireComponent(); + requireComponent(); + requireComponent(); + requireComponent(); + } + + void NewBuoyancy3System::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& buoy = e.getComponent(); + auto& rigidbody = e.getComponent(); + auto& transform = e.getComponent(); + auto& accumulator = e.getComponent(); + + Vector3 buoyPosition = transform.LocalToWorldPosition(buoy.positionOffset); + + Vector3 offset = buoy.positionOffset; + + float pitch = transform.GetEulerAngles().x; + + float length = buoy.positionOffset.length(); + + + + + if (buoyPosition.y < 0.0f) + { + float depth = buoyPosition.y; + + Vector3 force = Vector3(0.0f, UpForce(depth, buoy.volume), 0.0f); + + accumulator.AddForceAtPoint(force, buoyPosition, transform.GetPosition()); + + getWorld().data.renderUtil->DrawCube(buoyPosition, Vector3(1, 1, 1)); + } + } + } + + float NewBuoyancy3System::UpForce(float depth, float vol) + { + return (liquidDensity * vol * abs(depth) * 0.1f); + } +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancy3System.h b/OpenGLEngine/OpenGLEngine/NewBuoyancy3System.h new file mode 100644 index 0000000..8001159 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancy3System.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + class NewBuoyancy3System : public ECSSystem + { + public: + NewBuoyancy3System(); + void Update(float deltaTime); + float UpForce(float depth, float vol); + float liquidDensity = 10.5f; + float waterLevel = 0.0f; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancy4System.cpp b/OpenGLEngine/OpenGLEngine/NewBuoyancy4System.cpp new file mode 100644 index 0000000..0ac92f0 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancy4System.cpp @@ -0,0 +1,54 @@ +#include "NewBuoyancy4System.h" +#include "BuoyancyCenter4Component.h" +#include "RigidBodyComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" +#include "TransformComponentV2.h" + +namespace Reality +{ + NewBuoyancy4System::NewBuoyancy4System() + { + requireComponent(); + requireComponent(); + requireComponent(); + requireComponent(); + } + + void NewBuoyancy4System::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& buoy = e.getComponent(); + auto& rigidbody = e.getComponent(); + auto& transform = e.getComponent(); + auto& accumulator = e.getComponent(); + + Vector3 buoyPosition = transform.LocalToWorldPosition(buoy.positionOffset); + + Vector3 offset = buoy.positionOffset; + + float pitch = transform.GetEulerAngles().x; + + float length = buoy.positionOffset.length(); + + + + + if (buoyPosition.y < 0.0f) + { + float depth = buoyPosition.y; + + Vector3 force = Vector3(0.0f, UpForce(depth, buoy.volume), 0.0f); + + accumulator.AddForceAtPoint(force, buoyPosition, transform.GetPosition()); + + getWorld().data.renderUtil->DrawCube(buoyPosition, Vector3(1, 1, 1)); + } + } + } + + float NewBuoyancy4System::UpForce(float depth, float vol) + { + return (liquidDensity * vol * abs(depth) * 0.1f); + } +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancy4System.h b/OpenGLEngine/OpenGLEngine/NewBuoyancy4System.h new file mode 100644 index 0000000..1c266a2 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancy4System.h @@ -0,0 +1,15 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + class NewBuoyancy4System : public ECSSystem + { + public: + NewBuoyancy4System(); + void Update(float deltaTime); + float UpForce(float depth, float vol); + float liquidDensity = 10.5f; + float waterLevel = 0.0f; + }; +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancySystem.cpp b/OpenGLEngine/OpenGLEngine/NewBuoyancySystem.cpp new file mode 100644 index 0000000..feed30f --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancySystem.cpp @@ -0,0 +1,47 @@ +#include "NewBuoyancySystem.h" +#include "BuoyancyCenterComponent.h" +#include "RigidBodyComponent.h" +#include "ForceAndTorqueAccumulatorComponent.h" +#include "TransformComponentV2.h" + +namespace Reality +{ + NewBuoyancySystem::NewBuoyancySystem() + { + requireComponent(); + requireComponent(); + requireComponent(); + requireComponent(); + } + + void NewBuoyancySystem::Update(float deltaTime) + { + for (auto e : getEntities()) + { + auto& buoy = e.getComponent(); + auto& rigidbody = e.getComponent(); + auto& transform = e.getComponent(); + auto& accumulator = e.getComponent(); + + //Vector3 buoyPosition = transform.GetPosition() + buoy.positionOffset; + Vector3 buoyPosition = transform.LocalToWorldPosition(buoy.positionOffset); + + if(buoyPosition.y < 0.0f) + { + float depth = buoyPosition.y; + + Vector3 force = Vector3(0.0f, UpForce(depth, buoy.volume), 0.0f); + + accumulator.AddForceAtPoint(force, buoyPosition, transform.GetPosition()); + + getWorld().data.renderUtil->DrawCube(buoyPosition, Vector3(1, 1, 1)); + } + + } + } + + float NewBuoyancySystem::UpForce(float depth, float vol) + { + return (liquidDensity * vol * abs(depth) * 0.1f); + } +} diff --git a/OpenGLEngine/OpenGLEngine/NewBuoyancySystem.h b/OpenGLEngine/OpenGLEngine/NewBuoyancySystem.h new file mode 100644 index 0000000..5c7b84b --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/NewBuoyancySystem.h @@ -0,0 +1,16 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + class NewBuoyancySystem : public ECSSystem + { + public: + NewBuoyancySystem(); + void Update(float deltaTime); + float UpForce(float depth, float vol); + float liquidDensity = 10.5f; + float waterLevel = 0.0f; + }; + +} diff --git a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj index dbb8b45..887a823 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,29 @@ - + - + - - + - - + + - + - + @@ -160,25 +159,26 @@ - - + + + + + - + + - - - - + @@ -196,25 +196,49 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + - + @@ -222,26 +246,28 @@ - - + - - + - + - + - + + + + + @@ -253,52 +279,58 @@ - + - + - + - + - - - - + - + + + + + + + + + + - + + - + - + - + - @@ -320,42 +352,47 @@ - - - + - + - + - - + - - - + + + - - + - - + - + + + + + + + + + + + @@ -379,41 +416,78 @@ - + - + - - - - - - - - - - + - - + + + + + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -425,37 +499,36 @@ - - - - + - - - + - + - + - - + + - - + + + + + - + + diff --git a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters index 0199877..12c294a 100644 --- a/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters +++ b/OpenGLEngine/OpenGLEngine/OpenGLEngine.vcxproj.filters @@ -43,12 +43,36 @@ {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} + + + {26df7371-0611-42cd-b6e5-2556995c23d7} + + + {8f440b87-7f9c-4d7f-993c-ec5fa08dde39} + + + {8d7d692e-fedf-4e75-9661-f2eb1dd346c1} + + + {fee04adf-2290-4e0b-9dd6-1b2c67f5a98f} + @@ -81,27 +105,9 @@ ECSCore - - TestCS - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - Input - - TestCS - Rendering @@ -126,85 +132,97 @@ 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\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 + + + TestCS\FlightSimulator + + + TestCS\FlightSimulator - + Physics\Rigidbody - - TestCS + + Physics\Rigidbody - + + Physics\Rigidbody + + Physics\Rigidbody @@ -272,42 +290,12 @@ ECSCore - - TestCS - - - TestCS - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - - - Physics\Particles - Input Input - - TestCS - - - TestCS - Rendering @@ -332,154 +320,184 @@ 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\PairedSpring - - TestCS + + Physics\Particles\PairedSpring - - TestCS + + Physics\Particles - - TestCS + + Physics\Particles - - TestCS\FlightSim + + TestCS\ParticleSphereDemo - - TestCS\FlightSim + + TestCS\ParticleSphereDemo - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + TestCS\CablesAndRods - - TestCS\FlightSim + + Physics\Particles - - Rendering + + Physics\Particles - - Physics\Rigidbody + + ComponentsCore - - Physics\Rigidbody + + Rendering - - Physics\Rigidbody + + TestCS - - Physics\Rigidbody + + TestCS - - Physics\Particles + + TestCS - - Physics\Particles + + TestCS - + Physics\Rigidbody - + Physics\Rigidbody - + Physics\Rigidbody - + Physics\Rigidbody - + Physics\Rigidbody - + Physics\Rigidbody - - Physics\Particles + + TestCS - - Physics\Particles + + TestCS - - Physics\Particles + + TestCS\FlightSimulator - - Physics\Particles + + TestCS\FlightSimulator + + + TestCS\FlightSimulator + + + TestCS\FlightSimulator + + + TestCS\FlightSimulator + + + TestCS\FlightSimulator + + + TestCS\FlightSimulator + + + TestCS\FlightSimulator - + Physics\Rigidbody - + Physics\Rigidbody - - TestCS + + Physics\Rigidbody - - TestCS + + Physics\Rigidbody + + + Physics\Rigidbody + + + Physics\Rigidbody + + + Physics\Rigidbody + + + Physics\Rigidbody - + 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..8880728 100644 --- a/OpenGLEngine/OpenGLEngine/ParticleComponent.h +++ b/OpenGLEngine/OpenGLEngine/ParticleComponent.h @@ -5,30 +5,13 @@ 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/RealityComponent.h b/OpenGLEngine/OpenGLEngine/RealityComponent.h new file mode 100644 index 0000000..e31dde0 --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/RealityComponent.h @@ -0,0 +1,13 @@ +#pragma once +#include "ECSConfig.h" + +namespace Reality +{ + struct RealityComponent + { + RealityComponent() + { + + } + }; +} 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/Boats/Blank image.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/Blank image.jpg new file mode 100644 index 0000000..e69de29 diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/Blank.mtl b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/Blank.mtl new file mode 100644 index 0000000..e69de29 diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/BoatModel.FBX b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/BoatModel.FBX new file mode 100644 index 0000000..7240584 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/BoatModel.FBX differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/boatTest.fbx b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/boatTest.fbx new file mode 100644 index 0000000..3e5127b Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/boatTest.fbx differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/water Base Color.png b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/water Base Color.png new file mode 100644 index 0000000..1bccded Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/water Base Color.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood1.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood1.jpg new file mode 100644 index 0000000..93a8ac4 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood1.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood2.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood2.jpg new file mode 100644 index 0000000..3601738 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood2.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood3.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood3.jpg new file mode 100644 index 0000000..212bea3 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/Boats/wood3.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/Resources/Models/water/water Base Color.png b/OpenGLEngine/OpenGLEngine/Resources/Models/water/water Base Color.png new file mode 100644 index 0000000..1bccded Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/water/water Base Color.png differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/water/water-texture.jpg b/OpenGLEngine/OpenGLEngine/Resources/Models/water/water-texture.jpg new file mode 100644 index 0000000..868c665 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/water/water-texture.jpg differ diff --git a/OpenGLEngine/OpenGLEngine/Resources/Models/water/water.fbx b/OpenGLEngine/OpenGLEngine/Resources/Models/water/water.fbx new file mode 100644 index 0000000..da98a40 Binary files /dev/null and b/OpenGLEngine/OpenGLEngine/Resources/Models/water/water.fbx 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..0a0fe39 --- /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 = 10) + :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..f96595b --- /dev/null +++ b/OpenGLEngine/OpenGLEngine/ThrusterSystem.cpp @@ -0,0 +1,40 @@ +#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(); + + 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); } }; }