PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

rename Trigger to Sensor

Browse Source
This commit is contained in:
MihailRis 2024-07-09 07:37:20 +03:00
parent 0a14d6220a
commit c94c2697e7
11 changed files with 93 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
res/content/base/entities/drop.json
View File

@ -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]
],

4
res/content/base/scripts/components/drop.lua
View File

@ -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

24
src/content/ContentLoader.cpp
View File

@ -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")) {
for (size_t i = 0; i < triggersarr->size(); i++) {
if (auto triggerarr = triggersarr->list(i)) {
auto triggerType = triggerarr->str(0);
if (triggerType == "aabb") {
def.boxTriggers.push_back({i, {
{triggerarr->num(1), triggerarr->num(2), triggerarr->num(3)},
{triggerarr->num(4), triggerarr->num(5), triggerarr->num(6)}
if (auto sensorsarr = root->list("sensors")) {
for (size_t i = 0; i < sensorsarr->size(); i++) {
if (auto sensorarr = sensorsarr->list(i)) {
auto sensorType = sensorarr->str(0);
if (sensorType == "aabb") {
def.boxSensors.push_back({i, {
{sensorarr->num(1), sensorarr->num(2), sensorarr->num(3)},
{sensorarr->num(4), sensorarr->num(5), sensorarr->num(6)}
}});
} else if (triggerType == "radius") {
def.radialTriggers.push_back({i, triggerarr->num(1)});
} else if (sensorType == "radius") {
def.radialSensors.push_back({i, sensorarr->num(1)});
} else {
logger.error() << name << ": trigger #" << i << " - unknown type "
<< util::quote(triggerType);
logger.error() << name << ": sensor #" << i << " - unknown type "
<< util::quote(sensorType);
}
}
}

16
src/logic/scripting/scripting.cpp
View File

@ -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_trigger_exit = lua::hasfield(L, "on_trigger_exit");
funcsset.on_sensor_enter = lua::hasfield(L, "on_sensor_enter");
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) {
process_entity_callback(component->env, "on_trigger_enter", [index, oid](auto L) {
if (component->funcsset.on_sensor_enter) {
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) {
process_entity_callback(component->env, "on_trigger_exit", [index, oid](auto L) {
if (component->funcsset.on_sensor_exit) {
process_entity_callback(component->env, "on_sensor_exit", [index, oid](auto L) {
lua::pushinteger(L, index);
lua::pushinteger(L, oid);
return 2;

4
src/logic/scripting/scripting.hpp
View File

@ -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_trigger_exit(const Entity& entity, size_t index, entityid_t oid);
void on_sensor_enter(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(

74
src/objects/Entities.cpp
View File

@ -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());
for (auto& [i, box] : def.boxTriggers) {
TriggerParams params {};
body.sensors.resize(def.radialSensors.size() + def.boxSensors.size());
for (auto& [i, box] : def.boxSensors) {
SensorParams params {};
params.aabb = box;
body.triggers[i] = Trigger {
true, TriggerType::AABB, i, id, params, params, {}, {},
create_trigger_callback<scripting::on_trigger_enter>(this),
create_trigger_callback<scripting::on_trigger_exit>(this)};
body.sensors[i] = Sensor {
true, SensorType::AABB, i, id, params, params, {}, {},
create_sensor_callback<scripting::on_sensor_enter>(this),
create_sensor_callback<scripting::on_sensor_exit>(this)};
}
for (auto& [i, radius] : def.radialTriggers) {
TriggerParams params {};
for (auto& [i, radius] : def.radialSensors) {
SensorParams params {};
params.radial = glm::vec4(radius);
body.triggers[i] = Trigger {
true, TriggerType::RADIUS, i, id, params, params, {}, {},
create_trigger_callback<scripting::on_trigger_enter>(this),
create_trigger_callback<scripting::on_trigger_exit>(this)};
body.sensors[i] = Sensor {
true, SensorType::RADIUS, i, id, params, params, {}, {},
create_sensor_callback<scripting::on_sensor_enter>(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++) {
auto& trigger = rigidbody.triggers[i];
for (auto oid : trigger.prevEntered) {
if (trigger.nextEntered.find(oid) == trigger.nextEntered.end()) {
trigger.exitCallback(trigger.entity, i, oid);
for (size_t i = 0; i < rigidbody.sensors.size(); i++) {
auto& sensor = rigidbody.sensors[i];
for (auto oid : sensor.prevEntered) {
if (sensor.nextEntered.find(oid) == sensor.nextEntered.end()) {
sensor.exitCallback(sensor.entity, i, oid);
}
}
trigger.prevEntered = trigger.nextEntered;
trigger.nextEntered.clear();
sensor.prevEntered = sensor.nextEntered;
sensor.nextEntered.clear();
switch (trigger.type) {
case TriggerType::AABB:
trigger.calculated.aabb = trigger.params.aabb;
trigger.calculated.aabb.transform(transform.combined);
switch (sensor.type) {
case SensorType::AABB:
sensor.calculated.aabb = sensor.params.aabb;
sensor.calculated.aabb.transform(transform.combined);
break;
case TriggerType::RADIUS:
trigger.calculated.radial = glm::vec4(
case SensorType::RADIUS:
sensor.calculated.radial = glm::vec4(
rigidbody.hitbox.position.x,
rigidbody.hitbox.position.y,
rigidbody.hitbox.position.z,
trigger.params.radial.w*
trigger.params.radial.w);
sensor.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) {
if (trigger.type != TriggerType::AABB)
for (auto& sensor : rigidbody.sensors) {
if (sensor.type != SensorType::AABB)
continue;
batch.box(
trigger.calculated.aabb.center(),
trigger.calculated.aabb.size(),
sensor.calculated.aabb.center(),
sensor.calculated.aabb.size(),
glm::vec4(1.0f, 1.0f, 0.0f, 1.0f));
}
}

6
src/objects/Entities.hpp
View File

@ -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_trigger_exit : 1;
bool on_sensor_enter : 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 {

4
src/objects/EntityDef.hpp
View File

@ -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, float>> radialTriggers {};
std::vector<std::pair<size_t, AABB>> boxSensors {};
std::vector<std::pair<size_t, float>> radialSensors {};
std::string rigName = name;
struct {

20
src/physics/Hitbox.hpp
View File

@ -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;
TriggerParams calculated;
SensorParams params;
SensorParams calculated;
std::set<entityid_t> prevEntered;
std::set<entityid_t> nextEntered;
triggercallback enterCallback;
triggercallback exitCallback;
sensorcallback enterCallback;
sensorcallback exitCallback;
};
enum class BodyType {

24
src/physics/PhysicsSolver.cpp
View File

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

8
src/physics/PhysicsSolver.hpp
View File

@ -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) {
this->triggers = std::move(triggers);
void setSensors(std::vector<Sensor*> sensors) {
this->sensors = std::move(sensors);
}
};