rename Trigger to Sensor

res/content/base/entities/drop.json

@@ -3,7 +3,7 @@
         "drop"
     ],
     "hitbox": [0.2, 0.125, 0.2],
-    "triggers": [
+    "sensors": [
         ["aabb", -0.2, -0.2, -0.2, 0.2, 0.2, 0.2],
         ["radius", 1.6]
     ],

res/content/base/scripts/components/drop.lua

@@ -71,7 +71,7 @@ function on_fall()
     inair = true
 end
 
-function on_trigger_enter(index, oid)
+function on_sensor_enter(index, oid)
     local playerentity = player.get_entity(hud.get_player()):get_uid()
     if ready and oid == playerentity and index == 0 then
         entity:despawn()
@@ -83,7 +83,7 @@ function on_trigger_enter(index, oid)
     end
 end
 
-function on_trigger_exit(index, oid)
+function on_sensor_exit(index, oid)
     if oid == target and index == 1 then
         target = -1
     end

src/content/ContentLoader.cpp

@@ -317,20 +317,20 @@ void ContentLoader::loadEntity(EntityDef& def, const std::string& name, const fs
     if (auto boxarr = root->list("hitbox")) {
         def.hitbox = glm::vec3(boxarr->num(0), boxarr->num(1), boxarr->num(2));
     }
-    if (auto triggersarr = root->list("triggers")) {
+    if (auto sensorsarr = root->list("sensors")) {
-        for (size_t i = 0; i < triggersarr->size(); i++) {
+        for (size_t i = 0; i < sensorsarr->size(); i++) {
-            if (auto triggerarr = triggersarr->list(i)) {
+            if (auto sensorarr = sensorsarr->list(i)) {
-                auto triggerType = triggerarr->str(0);
+                auto sensorType = sensorarr->str(0);
-                if (triggerType == "aabb") {
+                if (sensorType == "aabb") {
-                    def.boxTriggers.push_back({i, {
+                    def.boxSensors.push_back({i, {
-                        {triggerarr->num(1), triggerarr->num(2), triggerarr->num(3)},
+                        {sensorarr->num(1), sensorarr->num(2), sensorarr->num(3)},
-                        {triggerarr->num(4), triggerarr->num(5), triggerarr->num(6)}
+                        {sensorarr->num(4), sensorarr->num(5), sensorarr->num(6)}
                     }});
-                } else if (triggerType == "radius") {
+                } else if (sensorType == "radius") {
-                    def.radialTriggers.push_back({i, triggerarr->num(1)});
+                    def.radialSensors.push_back({i, sensorarr->num(1)});
                 } else {
-                    logger.error() << name << ": trigger #" << i << " - unknown type "
+                    logger.error() << name << ": sensor #" << i << " - unknown type "
-                        << util::quote(triggerType);
+                        << util::quote(sensorType);
                 }
             }
         }

src/logic/scripting/scripting.cpp

@@ -318,8 +318,8 @@ void scripting::on_entity_spawn(
         funcsset.on_grounded = lua::hasfield(L, "on_grounded");
         funcsset.on_fall = lua::hasfield(L, "on_fall");
         funcsset.on_despawn = lua::hasfield(L, "on_despawn");
-        funcsset.on_trigger_enter = lua::hasfield(L, "on_trigger_enter");
+        funcsset.on_sensor_enter = lua::hasfield(L, "on_sensor_enter");
-        funcsset.on_trigger_exit = lua::hasfield(L, "on_trigger_exit");
+        funcsset.on_sensor_exit = lua::hasfield(L, "on_sensor_exit");
         funcsset.on_save = lua::hasfield(L, "on_save");
         lua::pop(L, 2);
 
@@ -391,11 +391,11 @@ bool scripting::on_entity_save(const Entity& entity) {
     return true;
 }
 
-void scripting::on_trigger_enter(const Entity& entity, size_t index, entityid_t oid) {
+void scripting::on_sensor_enter(const Entity& entity, size_t index, entityid_t oid) {
     const auto& script = entity.getScripting();
     for (auto& component : script.components) {
-        if (component->funcsset.on_trigger_enter) {
+        if (component->funcsset.on_sensor_enter) {
-            process_entity_callback(component->env, "on_trigger_enter", [index, oid](auto L) {
+            process_entity_callback(component->env, "on_sensor_enter", [index, oid](auto L) {
                 lua::pushinteger(L, index);
                 lua::pushinteger(L, oid);
                 return 2;
@@ -404,11 +404,11 @@ void scripting::on_trigger_enter(const Entity& entity, size_t index, entityid_t
     }
 }
 
-void scripting::on_trigger_exit(const Entity& entity, size_t index, entityid_t oid) {
+void scripting::on_sensor_exit(const Entity& entity, size_t index, entityid_t oid) {
     const auto& script = entity.getScripting();
     for (auto& component : script.components) {
-        if (component->funcsset.on_trigger_exit) {
+        if (component->funcsset.on_sensor_exit) {
-            process_entity_callback(component->env, "on_trigger_exit", [index, oid](auto L) {
+            process_entity_callback(component->env, "on_sensor_exit", [index, oid](auto L) {
                 lua::pushinteger(L, index);
                 lua::pushinteger(L, oid);
                 return 2;

src/logic/scripting/scripting.hpp

@@ -90,8 +90,8 @@ namespace scripting {
     bool on_entity_save(const Entity& entity);
     void on_entities_update();
     void on_entities_render();
-    void on_trigger_enter(const Entity& entity, size_t index, entityid_t oid);
+    void on_sensor_enter(const Entity& entity, size_t index, entityid_t oid);
-    void on_trigger_exit(const Entity& entity, size_t index, entityid_t oid);
+    void on_sensor_exit(const Entity& entity, size_t index, entityid_t oid);
 
     /// @brief Called on UI view show
     void on_ui_open(

src/objects/Entities.cpp

@@ -53,7 +53,7 @@ Entities::Entities(Level* level) : level(level) {
 }
 
 template<void(*callback)(const Entity&, size_t, entityid_t)>
-static triggercallback create_trigger_callback(Entities* entities) {
+static sensorcallback create_sensor_callback(Entities* entities) {
     return [=](auto entityid, auto index, auto otherid) {
         if (auto entity = entities->get(entityid)) {
             if (entity->isValid()) {
@@ -85,24 +85,24 @@ entityid_t Entities::spawn(
     const auto& tsf = registry.emplace<Transform>(
         entity, position, glm::vec3(1.0f), glm::mat3(1.0f), glm::mat4(1.0f), true);
     auto& body = registry.emplace<Rigidbody>(
-        entity, true, Hitbox {def.bodyType, position, def.hitbox}, std::vector<Trigger>{});
+        entity, true, Hitbox {def.bodyType, position, def.hitbox}, std::vector<Sensor>{});
 
-    body.triggers.resize(def.radialTriggers.size() + def.boxTriggers.size());
+    body.sensors.resize(def.radialSensors.size() + def.boxSensors.size());
-    for (auto& [i, box] : def.boxTriggers) {
+    for (auto& [i, box] : def.boxSensors) {
-        TriggerParams params {};
+        SensorParams params {};
         params.aabb = box;
-        body.triggers[i] = Trigger {
+        body.sensors[i] = Sensor {
-            true, TriggerType::AABB, i, id, params, params, {}, {},
+            true, SensorType::AABB, i, id, params, params, {}, {},
-            create_trigger_callback<scripting::on_trigger_enter>(this),
+            create_sensor_callback<scripting::on_sensor_enter>(this),
-            create_trigger_callback<scripting::on_trigger_exit>(this)};
+            create_sensor_callback<scripting::on_sensor_exit>(this)};
     }
-    for (auto& [i, radius] : def.radialTriggers) {
+    for (auto& [i, radius] : def.radialSensors) {
-        TriggerParams params {};
+        SensorParams params {};
         params.radial = glm::vec4(radius);
-        body.triggers[i] = Trigger {
+        body.sensors[i] = Sensor {
-            true, TriggerType::RADIUS, i, id, params, params, {}, {},
+            true, SensorType::RADIUS, i, id, params, params, {}, {},
-            create_trigger_callback<scripting::on_trigger_enter>(this),
+            create_sensor_callback<scripting::on_sensor_enter>(this),
-            create_trigger_callback<scripting::on_trigger_exit>(this)};
+            create_sensor_callback<scripting::on_sensor_exit>(this)};
     }
     auto& scripting = registry.emplace<ScriptComponents>(entity);
     entities[id] = entity;
@@ -247,7 +247,7 @@ void Entities::preparePhysics() {
     frameid++;
     auto view = registry.view<EntityId, Transform, Rigidbody>();
     auto physics = level->physics.get();
-    std::vector<Trigger*> triggers;
+    std::vector<Sensor*> sensors;
     for (auto [entity, eid, transform, rigidbody] : view.each()) {
         if (!rigidbody.enabled) {
             continue;
@@ -256,34 +256,34 @@ void Entities::preparePhysics() {
         if ((eid.uid + frameid) % 3 != 0) {
             continue;
         }
-        for (size_t i = 0; i < rigidbody.triggers.size(); i++) {
+        for (size_t i = 0; i < rigidbody.sensors.size(); i++) {
-            auto& trigger = rigidbody.triggers[i];
+            auto& sensor = rigidbody.sensors[i];
-            for (auto oid : trigger.prevEntered) {
+            for (auto oid : sensor.prevEntered) {
-                if (trigger.nextEntered.find(oid) == trigger.nextEntered.end()) {
+                if (sensor.nextEntered.find(oid) == sensor.nextEntered.end()) {
-                    trigger.exitCallback(trigger.entity, i, oid);
+                    sensor.exitCallback(sensor.entity, i, oid);
                 }
             }
-            trigger.prevEntered = trigger.nextEntered;
+            sensor.prevEntered = sensor.nextEntered;
-            trigger.nextEntered.clear();
+            sensor.nextEntered.clear();
 
-            switch (trigger.type) {
+            switch (sensor.type) {
-                case TriggerType::AABB:
+                case SensorType::AABB:
-                    trigger.calculated.aabb = trigger.params.aabb;
+                    sensor.calculated.aabb = sensor.params.aabb;
-                    trigger.calculated.aabb.transform(transform.combined);
+                    sensor.calculated.aabb.transform(transform.combined);
                     break;
-                case TriggerType::RADIUS:
+                case SensorType::RADIUS:
-                    trigger.calculated.radial = glm::vec4(
+                    sensor.calculated.radial = glm::vec4(
                         rigidbody.hitbox.position.x,
                         rigidbody.hitbox.position.y,
                         rigidbody.hitbox.position.z,
-                        trigger.params.radial.w*
+                        sensor.params.radial.w*
-                        trigger.params.radial.w);
+                        sensor.params.radial.w);
                     break;
             }
-            triggers.push_back(&trigger);
+            sensors.push_back(&sensor);
         }
     }
-    physics->setTriggers(std::move(triggers));
+    physics->setSensors(std::move(sensors));
 }
 
 void Entities::updatePhysics(float delta) {
@@ -337,12 +337,12 @@ void Entities::renderDebug(LineBatch& batch, const Frustum& frustum) {
         }
         batch.box(hitbox.position, hitbox.halfsize * 2.0f, glm::vec4(1.0f));
 
-        for (auto& trigger : rigidbody.triggers) {
+        for (auto& sensor : rigidbody.sensors) {
-            if (trigger.type != TriggerType::AABB)
+            if (sensor.type != SensorType::AABB)
                 continue;
             batch.box(
-                trigger.calculated.aabb.center(), 
+                sensor.calculated.aabb.center(), 
-                trigger.calculated.aabb.size(), 
+                sensor.calculated.aabb.size(), 
                 glm::vec4(1.0f, 1.0f, 0.0f, 1.0f));
         }
     }

src/objects/Entities.hpp

@@ -19,8 +19,8 @@ struct entity_funcs_set {
     bool on_despawn : 1;
     bool on_grounded : 1;
     bool on_fall : 1;
-    bool on_trigger_enter : 1;
+    bool on_sensor_enter : 1;
-    bool on_trigger_exit : 1;
+    bool on_sensor_exit : 1;
     bool on_save : 1;
 };
 
@@ -64,7 +64,7 @@ struct Transform {
 struct Rigidbody {
     bool enabled = true;
     Hitbox hitbox;
-    std::vector<Trigger> triggers;
+    std::vector<Sensor> sensors;
 };
 
 struct UserComponent {

src/objects/EntityDef.hpp

@@ -21,8 +21,8 @@ struct EntityDef {
 
     BodyType bodyType = BodyType::DYNAMIC;
     glm::vec3 hitbox {0.5f};
-    std::vector<std::pair<size_t, AABB>> boxTriggers {};
+    std::vector<std::pair<size_t, AABB>> boxSensors {};
-    std::vector<std::pair<size_t, float>> radialTriggers {};
+    std::vector<std::pair<size_t, float>> radialSensors {};
     std::string rigName = name;
 
     struct {

src/physics/Hitbox.hpp

@@ -10,32 +10,32 @@
 #include <functional>
 #include <glm/glm.hpp>
 
-enum class TriggerType {
+enum class SensorType {
     AABB,
     RADIUS,
 };
 
-union TriggerParams {
+union SensorParams {
     AABB aabb;
     glm::vec4 radial; // x,y,z calculated entity coords + w - radius
 
-    constexpr TriggerParams() : aabb() {
+    constexpr SensorParams() : aabb() {
     }
 };
 
-using triggercallback = std::function<void(entityid_t, size_t, entityid_t)>;
+using sensorcallback = std::function<void(entityid_t, size_t, entityid_t)>;
 
-struct Trigger {
+struct Sensor {
     bool enabled = true;
-    TriggerType type;
+    SensorType type;
     size_t index;
     entityid_t entity;
-    TriggerParams params;
+    SensorParams params;
-    TriggerParams calculated;
+    SensorParams calculated;
     std::set<entityid_t> prevEntered;
     std::set<entityid_t> nextEntered;
-    triggercallback enterCallback;
+    sensorcallback enterCallback;
-    triggercallback exitCallback;
+    sensorcallback exitCallback;
 };
 
 enum class BodyType {

src/physics/PhysicsSolver.cpp

@@ -87,28 +87,28 @@ void PhysicsSolver::step(
     AABB aabb;
     aabb.a = hitbox->position - hitbox->halfsize;
     aabb.b = hitbox->position + hitbox->halfsize;
-    for (size_t i = 0; i < triggers.size(); i++) {
+    for (size_t i = 0; i < sensors.size(); i++) {
-        auto& trigger = *triggers[i];
+        auto& sensor = *sensors[i];
-        if (trigger.entity == entity) {
+        if (sensor.entity == entity) {
             continue;
         }
 
         bool triggered = false;
-        switch (trigger.type) {
+        switch (sensor.type) {
-            case TriggerType::AABB:
+            case SensorType::AABB:
-                triggered = aabb.intersect(trigger.calculated.aabb);
+                triggered = aabb.intersect(sensor.calculated.aabb);
                 break;
-            case TriggerType::RADIUS:
+            case SensorType::RADIUS:
                 triggered = glm::distance2(
-                    hitbox->position, glm::vec3(trigger.calculated.radial))
+                    hitbox->position, glm::vec3(sensor.calculated.radial))
-                     < trigger.calculated.radial.w;
+                     < sensor.calculated.radial.w;
                 break;
         }
         if (triggered) {
-            if (trigger.prevEntered.find(entity) == trigger.prevEntered.end()) {
+            if (sensor.prevEntered.find(entity) == sensor.prevEntered.end()) {
-                trigger.enterCallback(trigger.entity, trigger.index, entity);
+                sensor.enterCallback(sensor.entity, sensor.index, entity);
             }
-            trigger.nextEntered.insert(entity);
+            sensor.nextEntered.insert(entity);
         }
     }
 }

src/physics/PhysicsSolver.hpp

@@ -11,11 +11,11 @@
 
 class Block;
 class Chunks;
-struct Trigger;
+struct Sensor;
 
 class PhysicsSolver {
     glm::vec3 gravity;
-    std::vector<Trigger*> triggers;
+    std::vector<Sensor*> sensors;
 public:
     PhysicsSolver(glm::vec3 gravity);
     void step(
@@ -36,8 +36,8 @@ public:
     bool isBlockInside(int x, int y, int z, Hitbox* hitbox);
     bool isBlockInside(int x, int y, int z, Block* def, blockstate state, Hitbox* hitbox);
 
-    void setTriggers(std::vector<Trigger*> triggers) {
+    void setSensors(std::vector<Sensor*> sensors) {
-        this->triggers = std::move(triggers);
+        this->sensors = std::move(sensors);
     }
 };