1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
#include "StarPhysicsObject.hpp"
#include "StarJsonExtra.hpp"
#include "StarInterpolation.hpp"
#include "StarRoot.hpp"
#include "StarObjectDatabase.hpp"
#include "StarLuaConverters.hpp"
namespace Star {
PhysicsObject::PhysicsObject(ObjectConfigConstPtr config, Json const& parameters) : Object(std::move(config), parameters) {
for (auto const& p : configValue("physicsForces", JsonObject()).iterateObject()) {
auto& forceConfig = m_physicsForces[p.first];
forceConfig.forceRegion = jsonToPhysicsForceRegion(p.second);
forceConfig.enabled.set(p.second.getBool("enabled", true));
}
for (auto const& p : configValue("physicsCollisions", JsonObject()).iterateObject()) {
auto& collisionConfig = m_physicsCollisions[p.first];
collisionConfig.movingCollision = PhysicsMovingCollision::fromJson(p.second);
collisionConfig.xPosition.set(take(collisionConfig.movingCollision.position[0]));
collisionConfig.yPosition.set(take(collisionConfig.movingCollision.position[1]));
collisionConfig.enabled.set(p.second.getBool("enabled", true));
}
m_physicsForces.sortByKey();
for (auto& p : m_physicsForces)
m_netGroup.addNetElement(&p.second.enabled);
m_physicsCollisions.sortByKey();
for (auto& p : m_physicsCollisions) {
m_netGroup.addNetElement(&p.second.xPosition);
m_netGroup.addNetElement(&p.second.yPosition);
p.second.xPosition.setInterpolator(lerp<float, float>);
p.second.yPosition.setInterpolator(lerp<float, float>);
m_netGroup.addNetElement(&p.second.enabled);
}
}
void PhysicsObject::enableInterpolation(float extrapolationHint) {
m_netGroup.enableNetInterpolation(extrapolationHint);
}
void PhysicsObject::disableInterpolation() {
m_netGroup.disableNetInterpolation();
}
void PhysicsObject::init(World* world, EntityId entityId, EntityMode mode) {
if (mode == EntityMode::Master) {
LuaCallbacks physicsCallbacks;
physicsCallbacks.registerCallback("setForceEnabled", [this](String const& force, bool enabled) {
m_physicsForces.get(force).enabled.set(enabled);
});
physicsCallbacks.registerCallback("setCollisionPosition", [this](String const& collision, Vec2F const& pos) {
auto& collisionConfig = m_physicsCollisions.get(collision);
collisionConfig.xPosition.set(pos[0]);
collisionConfig.yPosition.set(pos[1]);
});
physicsCallbacks.registerCallback("setCollisionEnabled", [this](String const& collision, bool const& enabled) {
auto& collisionConfig = m_physicsCollisions.get(collision);
collisionConfig.enabled.set(enabled);
});
m_scriptComponent.addCallbacks("physics", std::move(physicsCallbacks));
}
Object::init(world, entityId, mode);
m_metaBoundBox = Object::metaBoundBox();
for (auto const& p : m_physicsForces) {
PhysicsForceRegion forceRegion = p.second.forceRegion;
forceRegion.call([pos = position()](auto& fr) { fr.translate(pos); });
m_metaBoundBox.combine(forceRegion.call([](auto& fr) { return fr.boundBox(); }));
}
}
void PhysicsObject::uninit() {
m_scriptComponent.removeCallbacks("physics");
Object::uninit();
}
void PhysicsObject::update(float dt, uint64_t currentStep) {
Object::update(dt, currentStep);
if (isSlave())
m_netGroup.tickNetInterpolation(dt);
}
RectF PhysicsObject::metaBoundBox() const {
return m_metaBoundBox;
}
List<PhysicsForceRegion> PhysicsObject::forceRegions() const {
List<PhysicsForceRegion> forces;
for (auto const& p : m_physicsForces) {
if (p.second.enabled.get()) {
PhysicsForceRegion forceRegion = p.second.forceRegion;
forceRegion.call([pos = position()](auto& fr) { fr.translate(pos); });
forces.append(std::move(forceRegion));
}
}
return forces;
}
size_t PhysicsObject::movingCollisionCount() const {
return m_physicsCollisions.size();
}
Maybe<PhysicsMovingCollision> PhysicsObject::movingCollision(size_t positionIndex) const {
auto const& collisionConfig = m_physicsCollisions.valueAt(positionIndex);
if (!collisionConfig.enabled.get())
return {};
PhysicsMovingCollision collision = collisionConfig.movingCollision;
collision.translate(position() + Vec2F(collisionConfig.xPosition.get(), collisionConfig.yPosition.get()));
return collision;
}
}
|