sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'refs/remotes/origin/master' into enet_wip_nothing_to_see_here

This commit is contained in:
Jérôme Leclercq 2017-02-21 15:58:44 +01:00
parent 218d9f3974 7b47a6ad2e
commit 7322969b17
6 changed files with 179 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
include/Nazara/Physics2D/Collider2D.hpp
View File

@ -42,8 +42,15 @@ namespace Nz
virtual float ComputeInertialMatrix(float mass) const = 0;
inline unsigned int GetCollisionId() const;
virtual ColliderType2D GetType() const = 0;
inline bool IsTrigger() const;
inline void SetCollisionId(unsigned long typeId);
inline void SetTrigger(bool trigger);
Collider2D& operator=(const Collider2D&) = delete;
Collider2D& operator=(Collider2D&&) = delete;
@ -53,6 +60,12 @@ namespace Nz
protected:
virtual std::vector<cpShape*> CreateShapes(RigidBody2D* body) const = 0;
bool m_trigger;
unsigned int m_collisionId;
private:
virtual std::vector<cpShape*> GenerateShapes(RigidBody2D* body) const;
static Collider2DLibrary::LibraryMap s_library;
};

21
include/Nazara/Physics2D/Collider2D.inl
View File

@ -7,6 +7,26 @@
namespace Nz
{
inline unsigned int Collider2D::GetCollisionId() const
{
return m_collisionId;
}
inline bool Collider2D::IsTrigger() const
{
return m_trigger;
}
inline void Collider2D::SetCollisionId(unsigned long typeId)
{
m_collisionId = typeId;
}
inline void Collider2D::SetTrigger(bool trigger)
{
m_trigger = trigger;
}
inline const Rectf& BoxCollider2D::GetRect() const
{
return m_rect;
@ -82,3 +102,4 @@ namespace Nz
}
#include <Nazara/Physics2D/DebugOff.hpp>
#include "Collider2D.hpp"

28
include/Nazara/Physics2D/PhysWorld2D.hpp
View File

@ -10,14 +10,26 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <memory>
#include <unordered_map>
struct cpCollisionHandler;
struct cpSpace;
namespace Nz
{
class RigidBody2D;
class NAZARA_PHYSICS2D_API PhysWorld2D
{
using ContactEndCallback = void(*)(PhysWorld2D& world, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata);
using ContactPreSolveCallback = bool(*)(PhysWorld2D& world, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata);
using ContactPostSolveCallback = void(*)(PhysWorld2D& world, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata);
using ContactStartCallback = bool(*)(PhysWorld2D& world, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata);
public:
struct Callback;
PhysWorld2D();
PhysWorld2D(const PhysWorld2D&) = delete;
PhysWorld2D(PhysWorld2D&&) = delete; ///TODO
@ -27,8 +39,10 @@ namespace Nz
cpSpace* GetHandle() const;
float GetStepSize() const;
void RegisterCallbacks(unsigned int collisionId, const Callback& callbacks);
void RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, const Callback& callbacks);
void SetGravity(const Vector2f& gravity);
void SetSolverModel(unsigned int model);
void SetStepSize(float stepSize);
void Step(float timestep);
@ -36,7 +50,19 @@ namespace Nz
PhysWorld2D& operator=(const PhysWorld2D&) = delete;
PhysWorld2D& operator=(PhysWorld2D&&) = delete; ///TODO
struct Callback
{
ContactEndCallback endCallback;
ContactPreSolveCallback preSolveCallback;
ContactPostSolveCallback postSolveCallback;
ContactStartCallback startCallback;
void* userdata;
};
private:
void InitCallbacks(cpCollisionHandler* handler, const Callback& callbacks);
std::unordered_map<cpCollisionHandler*, std::unique_ptr<Callback>> m_callbacks;
cpSpace* m_handle;
float m_stepSize;
float m_timestepAccumulator;

12
src/Nazara/Physics2D/Collider2D.cpp
View File

@ -11,6 +11,18 @@ namespace Nz
{
Collider2D::~Collider2D() = default;
std::vector<cpShape*> Collider2D::GenerateShapes(RigidBody2D* body) const
{
std::vector<cpShape*> shapes = CreateShapes(body);
for (cpShape* shape : shapes)
{
cpShapeSetCollisionType(shape, m_collisionId);
cpShapeSetSensor(shape, (m_trigger) ? cpTrue : cpFalse);
}
return shapes;
}
/******************************** BoxCollider2D *********************************/
BoxCollider2D::BoxCollider2D(const Vector2f& size, float radius) :

105
src/Nazara/Physics2D/PhysWorld2D.cpp
View File

@ -37,6 +37,16 @@ namespace Nz
return m_stepSize;
}
void PhysWorld2D::RegisterCallbacks(unsigned int collisionId, const Callback& callbacks)
{
InitCallbacks(cpSpaceAddWildcardHandler(m_handle, collisionId), callbacks);
}
void PhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, const Callback& callbacks)
{
InitCallbacks(cpSpaceAddCollisionHandler(m_handle, collisionIdA, collisionIdB), callbacks);
}
void PhysWorld2D::SetGravity(const Vector2f& gravity)
{
cpSpaceSetGravity(m_handle, cpv(gravity.x, gravity.y));
@ -57,4 +67,99 @@ namespace Nz
m_timestepAccumulator -= m_stepSize;
}
}
void PhysWorld2D::InitCallbacks(cpCollisionHandler* handler, const Callback& callbacks)
{
auto it = m_callbacks.emplace(handler, std::make_unique<Callback>(callbacks)).first;
handler->userData = &it->second;
if (callbacks.startCallback)
{
handler->beginFunc = [](cpArbiter* arb, cpSpace* space, void *data) -> cpBool
{
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
const Callback* customCallbacks = static_cast<const Callback*>(data);
if (customCallbacks->startCallback(*world, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
{
cpBool retA = cpArbiterCallWildcardBeginA(arb, space);
cpBool retB = cpArbiterCallWildcardBeginB(arb, space);
return retA && retB;
}
else
return cpFalse;
};
}
if (callbacks.endCallback)
{
handler->separateFunc = [](cpArbiter* arb, cpSpace* space, void *data)
{
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
const Callback* customCallbacks = static_cast<const Callback*>(data);
customCallbacks->endCallback(*world, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
cpArbiterCallWildcardSeparateA(arb, space);
cpArbiterCallWildcardSeparateB(arb, space);
};
}
if (callbacks.preSolveCallback)
{
handler->preSolveFunc = [](cpArbiter* arb, cpSpace* space, void *data) -> cpBool
{
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
const Callback* customCallbacks = static_cast<const Callback*>(data);
if (customCallbacks->preSolveCallback(*world, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
{
cpBool retA = cpArbiterCallWildcardPreSolveA(arb, space);
cpBool retB = cpArbiterCallWildcardPreSolveB(arb, space);
return retA && retB;
}
else
return cpFalse;
};
}
if (callbacks.postSolveCallback)
{
handler->postSolveFunc = [](cpArbiter* arb, cpSpace* space, void *data)
{
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
const Callback* customCallbacks = static_cast<const Callback*>(data);
customCallbacks->postSolveCallback(*world, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
cpArbiterCallWildcardPostSolveA(arb, space);
cpArbiterCallWildcardPostSolveB(arb, space);
};
}
}
}

2
src/Nazara/Physics2D/RigidBody2D.cpp
View File

@ -190,7 +190,7 @@ namespace Nz
else
m_geom = NullCollider2D::New();
m_shapes = m_geom->CreateShapes(this);
m_shapes = m_geom->GenerateShapes(this);
cpSpace* space = m_world->GetHandle();
for (cpShape* shape : m_shapes)