BTH/squidout
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into water

Browse Source 
Conflicts:
	include/Core/Engine.h
	include/Physics/PhysicsSystem.h
	include/Sound/SoundSystem.h
	src/game/Physics/PhysicsSystem.cpp
	src/game/Sound/SoundSystem.cpp
PS:min teori i förra commiten var sann
This commit is contained in:
Stiffly
2015-10-07 18:34:36 +02:00
parent db2d6ad6e4 bfa8545483
commit 1a1b94477e
75 changed files with 9561 additions and 2755 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Physics/CCircleShape.h
+1 -1
View File
@@ -10,7 +10,7 @@ namespace Components
struct CircleShape : public Component
{
// Circles are circles
float Radius = 1.f;
};
}
include/Physics/CParticle.h
+38 -38
View File
@@ -7,24 +7,24 @@ namespace dd {
namespace ParticleFlags {
enum Type {
waterParticle = 0,
zombieParticle = 1 << 1,
wallParticle = 1 << 2,
springParticle = 1 << 3,
elasticParticle = 1 << 4,
viscousParticle = 1 << 5,
powderParticle = 1 << 6,
tensileParticle = 1 << 7,
colorMixingParticle = 1 << 8,
destructionListenerParticle = 1 << 9,
barrierParticle = 1 << 10,
staticPressureParticle = 1 << 11,
reactiveParticle = 1 << 12,
repulsiveParticle = 1 << 13,
fixtureContactListenerParticle = 1 << 14,
particleContactListenerParticle = 1 << 15,
fixtureContactFilterParticle = 1 << 16,
particleContactFilterParticle = 1 << 17
Water = 0,
Zombie = 1 << 1,
Wall = 1 << 2,
Spring = 1 << 3,
Elastic = 1 << 4,
Viscous = 1 << 5,
Powder = 1 << 6,
Tensile = 1 << 7,
ColorMixing = 1 << 8,
DestructionListener = 1 << 9,
Barrier = 1 << 10,
StaticPressure = 1 << 11,
Reactive = 1 << 12,
Repulsive = 1 << 13,
FixtureContactListener = 1 << 14,
ParticleContactListener = 1 << 15,
FixtureContactFilter = 1 << 16,
ParticleContactFilter = 1 << 17
};
}
@@ -36,26 +36,26 @@ struct Particle : public Component
float Radius = 0.5f;
float LifeTime = 5.0f;
ParticleFlags::Type Flags =
ParticleFlags::Type::waterParticle |
ParticleFlags::Type::zombieParticle |
ParticleFlags::Type::wallParticle |
ParticleFlags::Type::springParticle |
ParticleFlags::Type::elasticParticle |
ParticleFlags::Type::viscousParticle |
ParticleFlags::Type::powderParticle |
ParticleFlags::Type::tensileParticle |
ParticleFlags::Type::colorMixingParticle |
ParticleFlags::Type::destructionListenerParticle |
ParticleFlags::Type::barrierParticle |
ParticleFlags::Type::staticPressureParticle |
ParticleFlags::Type::reactiveParticle |
ParticleFlags::Type::repulsiveParticle |
ParticleFlags::Type::fixtureContactListenerParticle |
ParticleFlags::Type::particleContactListenerParticle |
ParticleFlags::Type::fixtureContactFilterParticle |
ParticleFlags::Type::particleContactFilterParticle;
ParticleFlags::Type Flags = static_cast<ParticleFlags::Type>(
ParticleFlags::Water
| ParticleFlags::Zombie
| ParticleFlags::Wall
| ParticleFlags::Spring
| ParticleFlags::Elastic
| ParticleFlags::Viscous
| ParticleFlags::Powder
| ParticleFlags::Tensile
| ParticleFlags::ColorMixing
| ParticleFlags::DestructionListener
| ParticleFlags::Barrier
| ParticleFlags::StaticPressure
| ParticleFlags::Reactive
| ParticleFlags::Repulsive
| ParticleFlags::FixtureContactListener
| ParticleFlags::ParticleContactListener
| ParticleFlags::FixtureContactFilter
| ParticleFlags::ParticleContactFilter
);
};
}
include/Physics/CParticleEmitter.h
+1 -1
View File
@@ -20,7 +20,7 @@ struct ParticleEmitter : public Component
float Speed = 2.f;
double LifeTime = 100;
//ParticleSystem variables
//System variables
float GravityScale = 1.0f;
};
include/Physics/CPhysics.h
+31 -15
View File
@@ -18,24 +18,40 @@ enum Type
Wall = 1 << 6
};
}
namespace Components
{
struct Physics: public Component
namespace CollisionType
{
bool Static = true;
bool Calculate = false;
float GravityScale = 0.f;
CollisionLayer::Type Category = CollisionLayer::Type::Other;
CollisionLayer::Type Mask =
CollisionLayer::Type::Pad |
CollisionLayer::Type::Ball |
CollisionLayer::Type::Brick |
CollisionLayer::Type::Water |
CollisionLayer::Type::PowerUp |
CollisionLayer::Type::Wall |
CollisionLayer::Type::Other;
enum Type
{
Static = 0,
Kinematic = 1,
Dynamic = 2,
};
}
namespace Components
{
struct Physics: public Component
{
CollisionType::Type CollisionType = CollisionType::Type::Static;
bool Calculate = false;
float GravityScale = 0.f;
CollisionLayer::Type Category = CollisionLayer::Type::Other;
CollisionLayer::Type Mask = static_cast<CollisionLayer::Type>(
CollisionLayer::Pad
| CollisionLayer::Ball
| CollisionLayer::Brick
| CollisionLayer::Water
| CollisionLayer::PowerUp
| CollisionLayer::Wall
| CollisionLayer::Other
);
};
}
}
include/Physics/CRectangleShape.h
+1 -1
View File
@@ -10,7 +10,7 @@ namespace Components
struct RectangleShape : public Component
{
glm::vec2 Dimensions = glm::vec2(1.f, 1.f);
};
}
include/Physics/ECreateParticleSequence.h
+1 -1
View File
@@ -26,7 +26,7 @@ struct CreateParticleSequence : public Event
//Particle
std::string SpriteFile = "Texures/Core/ErrorTexture.png";
double ParticleLifeTime = 3.f;
ParticleFlags::Type Flags = ParticleFlags::Type::powderParticle | ParticleFlags::Type::particleContactFilterParticle | ParticleFlags::Type::fixtureContactFilterParticle;
ParticleFlags::Type Flags = static_cast<ParticleFlags::Type>(ParticleFlags::Powder | ParticleFlags::ParticleContactFilter | ParticleFlags::FixtureContactFilter);
float Radius = 1.f;
};
include/Physics/PhysicsSystem.h
+130 -156
View File
@@ -2,118 +2,122 @@
#define DAYDREAM_PHYSICSSYSTEM_H
#include <unordered_map>
#include <random>
#include <glm/gtc/quaternion.hpp>
#include <Box2D/Box2D.h>
#include "Core/System.h"
#include "Core/World.h"
#include "CRectangleShape.h"
#include "Physics/CPhysics.h"
#include <Box2D/Box2D.h>
#include "Core/CTransform.h"
#include "Transform/TransformSystem.h"
#include "Physics/EContact.h"
#include "Physics/ESetImpulse.h"
#include "Physics/ECreateParticleSequence.h"
#include "Physics/CCircleShape.h"
#include "Core/EventBroker.h"
#include "Game/CPad.h"
#include "Physics/CWaterVolume.h"
#include "Game/CBall.h"
#include "Rendering/CSprite.h"
#include "Physics/CParticle.h"
#include "Physics/CParticleEmitter.h"
#include "Core/CTemplate.h"
#include "Physics/CRectangleShape.h"
#include "Physics/CCircleShape.h"
#include "Physics/CPhysics.h"
#include "Physics/CWaterVolume.h"
#include "Core/CTransform.h"
#include "Transform/TransformSystem.h"
#include "CRectangleShape.h"
#include "Physics/CPhysics.h"
#include "Physics/EContact.h"
#include "Physics/ESetImpulse.h"
#include "Physics/CParticle.h"
#include "Physics/ECreateParticleSequence.h"
#include "Physics/CCircleShape.h"
#include "Physics/CParticleEmitter.h"
#include "Game/CPad.h"
#include "Game/CPad.h"
#include "Game/CBall.h"
#include "Transform/TransformSystem.h"
#include "Rendering/CSprite.h"
#include "Core/CTemplate.h"
#include "Game/EPause.h"
namespace dd
{
namespace Systems
{
class PhysicsSystem : public System
{
friend class ContractListener;
friend class DestructionListener;
public:
PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
: System(world, eventBroker) {}
~PhysicsSystem();
EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
bool SetImpulse(const Events::SetImpulse &event);
EventRelay<PhysicsSystem, Events::CreateParticleSequence> m_ECreateParticleSequence;
bool CreateParticleSequence(const Events::CreateParticleSequence &event);
void RegisterComponents(ComponentFactory* cf) override;
void Initialize() override;
// Called once per system every tick
void Update(double dt) override;
// Called once for every entity in the world every tick
void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
// Called when components are committed to an entity
void OnEntityCommit(EntityID entity) override;
// Called when an entity is removed
void OnEntityRemoved(EntityID entity) override;
private:
b2Vec2 m_Gravity;
b2World* m_PhysicsWorld;
float m_TimeStep;
float m_Accumulator;
int m_VelocityIterations, m_PositionIterations;
std::mt19937 gen;
std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
void CreateBody(EntityID entity);
b2ParticleSystem* m_WaterParticleSystem;
std::vector<b2ParticleGroup*> t_ParticleGroup;
std::unordered_map<EntityID, const b2ParticleHandle*> m_EntitiesToWaterParticleHandle;
std::unordered_map<const b2ParticleHandle*, EntityID> m_WaterParticleHandleToEntities;
std::vector<std::unordered_map<EntityID, const b2ParticleHandle*>> m_EntitiesToParticleHandle;
std::vector<std::unordered_map<const b2ParticleHandle*, EntityID>> m_ParticleHandleToEntities;
b2ParticleSystem* CreateParticleSystem(float radius, float gravityScale, int maxCount);
void InitializeWater();
void CreateParticleGroup(EntityID entity);
void CreateParticleEmitter(EntityID entity);
void UpdateParticleEmitters(double dt); //TODO: Remove them and particles if needed.
//TODO: Fill struct with info needed.
struct ParticleEmitter
namespace Systems
{
std::vector<b2ParticleSystem*> ParticleSystem;
std::vector<EntityID> ParticleEmitter;
std::vector<EntityID> ParticleTemplate;
};
ParticleEmitter m_ParticleEmitters;
//TODO: Struct med listor är bättre än en lista med structs
struct Impulse
{
b2Body* Body;
b2Vec2 Impulse;
b2Vec2 Point;
};
std::list<Impulse> m_Impulses;
class PhysicsSystem : public System
{
friend class ContractListener;
friend class DestructionListener;
class DestructionListener : public b2DestructionListener
public:
PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
: System(world, eventBroker) { }
~PhysicsSystem();
EventRelay<PhysicsSystem, Events::CreateParticleSequence> m_ECreateParticleSequence;
bool CreateParticleSequence(const Events::CreateParticleSequence &event);
void RegisterComponents(ComponentFactory* cf) override;
void Initialize() override;
void Update(double dt) override;
void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
void OnEntityCommit(EntityID entity) override;
void OnEntityRemoved(EntityID entity) override;
private:
struct Impulse
{
b2Body* Body;
b2Vec2 Vector;
b2Vec2 Point;
};
bool m_Pause = false;
std::mt19937 gen;
b2Vec2 m_Gravity = b2Vec2(0.f, -9.82f);
b2World* m_PhysicsWorld = nullptr;
float m_TimeStep = 1.f/60.f;
float m_Accumulator = 0.f;
int m_VelocityIterations = 6;
int m_PositionIterations = 2;
b2ParticleSystem* m_WaterParticleSystem;
std::vector<b2ParticleGroup*> t_ParticleGroup;
std::unordered_map<const b2ParticleHandle*, EntityID> m_WaterParticleHandleToEntities;
std::unordered_map<EntityID, const b2ParticleHandle*> m_EntitiesToWaterParticleHandle;
std::vector<std::unordered_map<EntityID, const b2ParticleHandle*>> m_EntitiesToParticleHandle;
std::vector<std::unordered_map<const b2ParticleHandle*, EntityID>> m_ParticleHandleToEntities;
std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
void CreateBody(EntityID entity);
void SyncEntitiesWithBodies();
void SyncBodiesWithEntities();
void InitializeWater();
void CreateParticleGroup(EntityID entity);
b2ParticleSystem* CreateParticleSystem(float radius, float gravityScale, int maxCount);
void CreateParticleEmitter(EntityID entity);
void UpdateParticleEmitters(double dt); //TODO: Remove them and particles if needed.
EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
bool SetImpulse(const Events::SetImpulse &event);
dd::EventRelay<PhysicsSystem, dd::Events::Pause> m_EPause;
bool OnPause(const dd::Events::Pause &event);
//TODO: Fill struct with info needed.
struct ParticleEmitter //TODO CHANGE NAMES
{
std::vector<b2ParticleSystem*> ParticleSystem;
std::vector<EntityID> ParticleEmitter;
std::vector<EntityID> ParticleTemplate;
};
ParticleEmitter m_ParticleEmitters;
std::list<Impulse> m_Impulses;
class DestructionListener : public b2DestructionListener
{
public:
DestructionListener(PhysicsSystem* physicsSystem)
@@ -127,7 +131,7 @@ private:
LOG_INFO("Particle ded");
b2ParticleHandle* handle = particleSystem->GetParticleHandleFromIndex(index);
const b2ParticleHandle* handle = particleSystem->GetParticleHandleFromIndex(index);
for (int i = 0; i < m_PhysicsSystem->m_ParticleEmitters.ParticleSystem.size(); i++) {
if(m_PhysicsSystem->m_ParticleEmitters.ParticleSystem[i] == particleSystem) {
std::unordered_map<const b2ParticleHandle*, EntityID>::iterator it = m_PhysicsSystem->m_ParticleHandleToEntities[i].find(handle);
@@ -144,57 +148,7 @@ private:
PhysicsSystem* m_PhysicsSystem;
};
class ContactListener : public b2ContactListener
{
public:
ContactListener(PhysicsSystem* physicsSystem)
: m_PhysicsSystem(physicsSystem) { }
void BeginContact(b2Contact* contact)
{
b2WorldManifold worldManifold;
contact->GetWorldManifold(&worldManifold);
Events::Contact e;
e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
m_PhysicsSystem->EventBroker->Publish(e);
}
void EndContact(b2Contact* contact)
{
}
void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
{
EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
if (physicsComponentA != nullptr && physicsComponentB != nullptr) {
if (physicsComponentA->Calculate || physicsComponentB->Calculate) {
// Turn of collisions
contact->SetEnabled(false);
}
}
}
void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
{
}
private:
PhysicsSystem* m_PhysicsSystem;
};
class ParticleContactDisabler : public b2ContactFilter
class ParticleContactDisabler : public b2ContactFilter
{
public:
ParticleContactDisabler() { };
@@ -211,12 +165,32 @@ private:
};
DestructionListener* m_DestructionListener;
ParticleContactDisabler m_ParticleContactDisabler;
ContactListener* m_ContactListener;
};
}
class ContactListener : public b2ContactListener
{
public:
ContactListener(PhysicsSystem* physicsSystem)
: m_PhysicsSystem(physicsSystem) { }
void BeginContact(b2Contact* contact);
void EndContact(b2Contact* contact);
void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);
private:
PhysicsSystem* m_PhysicsSystem;
};
DestructionListener* m_DestructionListener;
ParticleContactDisabler m_ParticleContactDisabler;
ContactListener* m_ContactListener;
};
}
}
#endif //DAYDREAM_PHYSICSSYSTEM_H
#endif
include/Physics/PhysicsSystem.h.orig
-149
View File
@@ -1,149 +0,0 @@
#ifndef DAYDREAM_PHYSICSSYSTEM_H
#define DAYDREAM_PHYSICSSYSTEM_H
#include <unordered_map>
#include "Core/System.h"
#include "Core/World.h"
#include "CRectangleShape.h"
#include "Physics/CPhysics.h"
#include <Box2D/Box2D.h>
#include "Core/CTransform.h"
#include "Transform/TransformSystem.h"
#include "Physics/EContact.h"
#include "Physics/ESetImpulse.h"
#include "Physics/CCircleShape.h"
#include "Core/EventBroker.h"
#include "Game/CPad.h"
<<<<<<< HEAD
#include "Game/CBall.h"
=======
#include "Physics/CWaterVolume.h"
#include "Rendering/CSprite.h"
>>>>>>> origin/master
namespace dd
{
namespace Systems
{
class PhysicsSystem : public System
{
friend class ContractListener;
public:
PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
: System(world, eventBroker) {}
~PhysicsSystem();
EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
bool SetImpulse(const Events::SetImpulse &event);
void RegisterComponents(ComponentFactory* cf) override;
void Initialize() override;
// Called once per system every tick
void Update(double dt) override;
// Called once for every entity in the world every tick
void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
// Called when components are committed to an entity
void OnEntityCommit(EntityID entity) override;
// Called when an entity is removed
void OnEntityRemoved(EntityID entity) override;
private:
b2Vec2 m_Gravity;
b2World* m_PhysicsWorld;
float m_TimeStep;
float m_Accumulator;
int m_VelocityIterations, m_PositionIterations;
std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
void CreateBody(EntityID entity);
b2ParticleSystem *m_ParticleSystem;
b2ParticleGroup* t_watergroup;
std::unordered_map<EntityID, const b2ParticleHandle*> m_EntitiesToParticleHandle;
std::unordered_map<const b2ParticleHandle*, EntityID> m_ParticleHandleToEntities;
void InitializeWater();
void SyncWater(); //TODO: Probably remove this
void CreateParticleGroup(EntityID entity);
struct Impulse
{
b2Body* Body;
b2Vec2 Impulse;
b2Vec2 Point;
};
std::list<Impulse> m_Impulses;
class ContactListener : public b2ContactListener
{
public:
ContactListener(PhysicsSystem* physicsSystem)
: m_PhysicsSystem(physicsSystem) { }
void BeginContact(b2Contact* contact)
{
b2WorldManifold worldManifold;
contact->GetWorldManifold(&worldManifold);
Events::Contact e;
e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
m_PhysicsSystem->EventBroker->Publish(e);
}
void EndContact(b2Contact* contact)
{
}
void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
{
EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
if (physicsComponentA != nullptr && physicsComponentB != nullptr) {
if (physicsComponentA->Calculate || physicsComponentB->Calculate) {
// Turn of collisions
contact->SetEnabled(false);
}
}
}
void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
{
}
private:
PhysicsSystem* m_PhysicsSystem;
};
ContactListener* m_ContactListener;
};
}
}
#endif //DAYDREAM_PHYSICSSYSTEM_H