add advanced entities.raycast overload

src/graphics/render/Decorator.cpp

@@ -22,6 +22,7 @@
 #include "voxels/Block.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
+#include "voxels/blocks_agent.hpp"
 #include "window/Camera.hpp"
 #include "world/Level.hpp"
 #include "WorldRenderer.hpp"
@@ -98,7 +99,7 @@ void Decorator::updateAcoustics(const Camera& camera) {
 
     auto& chunks = *player.chunks;
     const auto& start = camera.position;
-    float rayLength = 40.0f;
+    float length = 40.0f;
 
     auto& blocks = level.content.getIndices()->blocks;
 
@@ -107,7 +108,7 @@ void Decorator::updateAcoustics(const Camera& camera) {
     float averageDistance = 0.0f;
     float averageAbsorption = 0.0f;
     float speedOfSound = 300.0f;
-    float minDistance = rayLength;
+    float minDistance = length;
     for (int i = 0; i < rays; i++) {
         float u1 = random.randFloat();
         float u2 = random.randFloat();
@@ -121,12 +122,13 @@ void Decorator::updateAcoustics(const Camera& camera) {
         glm::vec3 end;
         glm::ivec3 norm;
         glm::ivec3 iend;
-        auto vox = chunks.rayCast(start, dir, rayLength, end, norm, iend);
+        blocks_agent::RaycastSettings raycast {};
+        auto vox = chunks.rayCast(start, dir, length, end, norm, iend, raycast);
         if (vox == nullptr) {
             continue;
         }
         auto distance = glm::distance(start, end);
-        if (distance >= rayLength * 0.98f) {
+        if (distance >= length * 0.98f) {
             continue;
         }
         if (distance < minDistance) {
@@ -149,7 +151,7 @@ void Decorator::updateAcoustics(const Camera& camera) {
         averageAbsorption /= hit;
     }
 
-    float decayTime = 20.0f * (averageDistance / rayLength);
+    float decayTime = 20.0f * (averageDistance / length);
     float escapeRatio = static_cast<float>(rays - hit) / static_cast<float>(rays);
 
     acoustics.reverbGain = glm::pow(hit / static_cast<float>(rays), 3.0f);

src/logic/PlayerController.cpp

@@ -200,8 +200,13 @@ void CameraControl::update(
     auto castRay = [](Player& player, Camera& camera, const glm::vec3& front)
          -> glm::vec3 {
         auto blockEnd = player.chunks->rayCastToObstacle(camera.position, front, 3.0f);
+
+        Entities::RaycastSettings raycast {};
+        raycast.ignoredUid = player.getEntity();
+        raycast.solidEntitiesOnly = true;
+
         auto entityRay = player.getLevel().entities->rayCast(
-            camera.position, front, 3.0f, player.getEntity(), true
+            camera.position, front, 3.0f, raycast
         );
         if (entityRay.has_value() &&
             entityRay->distance < glm::distance(camera.position, blockEnd)) {
@@ -350,7 +355,13 @@ voxel* PlayerController::updateSelection(float maxDistance) {
     glm::ivec3 iend;
     glm::ivec3 norm;
     voxel* vox = chunks.rayCast(
-        camera->position, camera->front, maxDistance, end, norm, iend
+        camera->position,
+        camera->front,
+        maxDistance,
+        end,
+        norm,
+        iend,
+        blocks_agent::RaycastSettings {}
     );
     if (vox) {
         maxDistance = glm::distance(camera->position, end);
@@ -358,8 +369,12 @@ voxel* PlayerController::updateSelection(float maxDistance) {
     auto prevEntity = selection.entity;
     selection.entity = ENTITY_NONE;
     selection.actualPosition = iend;
+
+    Entities::RaycastSettings raycast {};
+    raycast.ignoredUid = player.getEntity();
+
     if (auto result = level.entities->rayCast(
-            camera->position, camera->front, maxDistance, player.getEntity()
+            camera->position, camera->front, maxDistance, raycast
         )) {
         selection.entity = result->entity;
         selection.hitPosition =

src/logic/scripting/lua/libs/libblock.cpp

@@ -543,13 +543,16 @@ static int l_destruct(lua::State* L) {
 }
 
 static int l_raycast(lua::State* L) {
-    auto& level = require_level();
+    const auto& level = require_level();
 
     auto start = lua::tovec<3>(L, 1);
     auto dir = lua::tovec<3>(L, 2);
     auto maxDistance = lua::tonumber(L, 3);
-    bool includeNonSelectable = false;
+
+    blocks_agent::RaycastSettings raycast {};
     std::set<blockid_t> filteredBlocks {};
+    raycast.filter = &filteredBlocks;
+
     const int luaStackSize = lua::gettop(L);
     if (luaStackSize >= 5) {
         if (lua::istable(L, 5)) {
@@ -568,21 +571,14 @@ static int l_raycast(lua::State* L) {
         }
     }
     if (luaStackSize >= 6) {
-        includeNonSelectable = lua::toboolean(L, 6);
+        raycast.includeNonSelectable = lua::toboolean(L, 6);
     }
     glm::vec3 end;
     glm::ivec3 normal;
     glm::ivec3 iend;
+
     if (auto voxel = blocks_agent::raycast(
-            *level.chunks,
+            *level.chunks, start, dir, maxDistance, end, normal, iend, raycast
-            start,
-            dir,
-            maxDistance,
-            end,
-            normal,
-            iend,
-            filteredBlocks,
-            includeNonSelectable
         )) {
         if (luaStackSize >= 4 && !lua::isnil(L, 4)) {
             lua::pushvalue(L, 4);

src/logic/scripting/lua/libs/libentity.cpp

@@ -17,6 +17,8 @@
 #include "voxels/blocks_agent.hpp"
 #include "window/Camera.hpp"
 
+#include <set>
+
 using namespace scripting;
 
 static const EntityDef* require_entity_def(lua::State* L) {
@@ -145,34 +147,58 @@ static int l_get_all_in_radius(lua::State* L) {
     return 1;
 }
 
-static int l_raycast(lua::State* L) {
+static int l_push_ray(
-    auto start = lua::tovec<3>(L, 1);
+    lua::State* L,
-    auto dir = lua::tovec<3>(L, 2);
+    const std::optional<Entities::RaycastResult>& ray,
-    auto maxDistance = lua::tonumber(L, 3);
+    blockid_t block,
-    auto ignoreEntityId = lua::tointeger(L, 4);
+    const glm::vec3& start,
-    bool includeNonSelectable = false;
+    const glm::vec3& dir,
-    std::set<blockid_t> filteredBlocks {};
+    const glm::vec3& end,
-    const int luaStackSize = lua::gettop(L);
+    const glm::ivec3& iend,
-    if (luaStackSize >= 6) {
+    const glm::ivec3& normal
-        if (lua::istable(L, 6)) {
+) {
-            int addLen = lua::objlen(L, 6);
+    if (!ray.has_value() && block == BLOCK_VOID) {
-            for (int i = 0; i < addLen; i++) {
+        return 0;
-                lua::rawgeti(L, i + 1, 6);
-                auto blockName = std::string(lua::tostring(L, -1));
-                const Block* block = content->blocks.find(blockName);
-                if (block != nullptr) {
-                    filteredBlocks.insert(block->rt.id);
-                }
-                lua::pop(L);
-            }
-        } else {
-            throw std::runtime_error("table expected for filter");
-        }
     }
-    if (luaStackSize >= 7) {
+    if (lua::gettop(L) >= 5 && lua::istable(L, 5)) {
-        includeNonSelectable = lua::toboolean(L, 6);
+        lua::pushvalue(L, 5);
+    } else {
+        lua::createtable(L, 0, 6);
     }
 
+    lua::pushvec3(L, ray ? (start + dir * ray->distance) : end);
+    lua::setfield(L, "endpoint");
+
+    lua::pushvec3(L, ray ? ray->normal : normal);
+    lua::setfield(L, "normal");
+
+    lua::pushnumber(L, glm::distance(start, end));
+    lua::setfield(L, "length");
+
+    lua::pushvec3(L, iend);
+    lua::setfield(L, "iendpoint");
+
+    lua::pushinteger(L, block);
+    lua::setfield(L, "block");
+
+    if (ray.has_value()) {
+        lua::pushinteger(L, ray->entity);
+        lua::setfield(L, "entity");
+    } else if (block != BLOCK_VOID) {
+        lua::pushinteger(L, block);
+        lua::setfield(L, "block");
+    }
+    return 1;
+}
+
+static int l_raycast(
+    lua::State* L,
+    const glm::vec3& start,
+    const glm::vec3& dir,
+    float maxDistance,
+    const blocks_agent::RaycastSettings& voxelRaycast,
+    const Entities::RaycastSettings& entityRaycast
+) {
     glm::vec3 end;
     glm::ivec3 normal;
     glm::ivec3 iend;
@@ -187,61 +213,108 @@ static int l_raycast(lua::State* L) {
             end,
             normal,
             iend,
-            filteredBlocks,
+            voxelRaycast
-            includeNonSelectable
         )) {
         maxDistance = glm::distance(start, end);
         block = voxel->id;
     }
-    if (auto ray =
+    auto ray = level->entities->rayCast(start, dir, maxDistance, entityRaycast);
-            level->entities->rayCast(start, dir, maxDistance, ignoreEntityId)) {
+    return l_push_ray(L, ray, block, start, dir, end, iend, normal);
-        if (luaStackSize >= 5 && !lua::isnil(L, 5)) {
+}
-            lua::pushvalue(L, 5);
+
-        } else {
+static void load_blocks_filter(lua::State* L, int idx, std::set<blockid_t>& dst) {
-            lua::createtable(L, 0, 6);
+    int count = lua::objlen(L, idx);
+    for (int i = 0; i < count; i++) {
+        lua::rawgeti(L, i + 1, idx);
+        auto blockName = std::string(lua::tostring(L, -1));
+        const Block* block = content->blocks.find(blockName);
+        if (block != nullptr) {
+            dst.insert(block->rt.id);
         }
-
+        lua::pop(L);
-        lua::pushvec3(L, start + dir * ray->distance);
-        lua::setfield(L, "endpoint");
-
-        lua::pushvec3(L, ray->normal);
-        lua::setfield(L, "normal");
-
-        lua::pushnumber(L, glm::distance(start, end));
-        lua::setfield(L, "length");
-
-        lua::pushvec3(L, iend);
-        lua::setfield(L, "iendpoint");
-
-        lua::pushinteger(L, block);
-        lua::setfield(L, "block");
-
-        lua::pushinteger(L, ray->entity);
-        lua::setfield(L, "entity");
-        return 1;
-    } else if (block != BLOCK_VOID) {
-        if (lua::gettop(L) >= 5 && !lua::isnil(L, 5)) {
-            lua::pushvalue(L, 5);
-        } else {
-            lua::createtable(L, 0, 5);
-        }
-        lua::pushvec3(L, end);
-        lua::setfield(L, "endpoint");
-
-        lua::pushvec3(L, normal);
-        lua::setfield(L, "normal");
-
-        lua::pushnumber(L, glm::distance(start, end));
-        lua::setfield(L, "length");
-
-        lua::pushvec3(L, iend);
-        lua::setfield(L, "iendpoint");
-
-        lua::pushinteger(L, block);
-        lua::setfield(L, "block");
-        return 1;
     }
-    return 0;
+}
+
+static void load_entities_filter(lua::State* L, int idx, std::set<entitydefid_t>& dst) {
+    int count = lua::objlen(L, idx);
+    for (int i = 0; i < count; i++) {
+        lua::rawgeti(L, i + 1, idx);
+        auto entityName = std::string(lua::tostring(L, -1));
+        const EntityDef* entity = content->entities.find(entityName);
+        if (entity != nullptr) {
+            dst.insert(entity->rt.id);
+        }
+        lua::pop(L);
+    }
+}
+
+static int l_raycast(lua::State* L) {
+    blocks_agent::RaycastSettings blocksRaycast {};
+    Entities::RaycastSettings entityRaycast {};
+
+    std::set<blockid_t> filteredBlocks {};
+    std::set<entitydefid_t> filteredEntities {};
+
+    glm::vec3 start, dir;
+    float maxDistance;
+
+    const int luaStackSize = lua::gettop(L);
+    if (luaStackSize == 1) {
+        if (!lua::istable(L, 1)) {
+            throw std::runtime_error("invalid function overload");
+        }
+
+        lua::requirefield(L, "start", 1);
+        start = lua::tovec3(L, -1);
+
+        lua::requirefield(L, "dir", 1);
+        dir = lua::tovec3(L, -1);
+
+        lua::requirefield(L, "distance", 1);
+        maxDistance = lua::tonumber(L, -1);
+
+        lua::pop(L, 3);
+
+        if (lua::getfield(L, "ignore_uid", 1)) {
+            entityRaycast.ignoredUid = lua::tointeger(L, -1);
+            lua::pop(L);
+        }
+        if (lua::getfield(L, "ignore_entities")) {
+            load_entities_filter(L, -1, filteredEntities);
+            lua::pop(L);
+        }
+        if (lua::getfield(L, "entities_exclusion")) {
+            entityRaycast.entityFilterExcludeMode = lua::toboolean(L, -1);
+            lua::pop(L);
+        }
+        if (lua::getfield(L, "filter_blocks", 1)) {
+            load_blocks_filter(L, -1, filteredBlocks);
+            lua::pop(L);
+        }
+    } else {
+        start = lua::tovec<3>(L, 1);
+        dir = lua::tovec<3>(L, 2);
+        maxDistance = lua::tonumber(L, 3);
+
+        entityRaycast.ignoredUid = lua::tointeger(L, 4);
+        if (luaStackSize >= 6) {
+            if (lua::istable(L, 6)) {
+                load_blocks_filter(L, 6, filteredBlocks);
+            } else {
+                throw std::runtime_error("table expected for filter");
+            }
+        }
+        if (luaStackSize >= 7) {
+            blocksRaycast.includeNonSelectable = lua::toboolean(L, 6);
+        }
+    }
+    if (!filteredBlocks.empty()) {
+        blocksRaycast.filter = &filteredBlocks;
+    }
+    if (!filteredEntities.empty()) {
+        blocksRaycast.filter = &filteredEntities;
+    }
+    return l_raycast(L, start, dir, maxDistance, blocksRaycast, entityRaycast);
 }
 
 static int l_reload_component(lua::State* L) {

src/objects/Entities.cpp

@@ -166,8 +166,7 @@ std::optional<Entities::RaycastResult> Entities::rayCast(
     glm::vec3 start,
     glm::vec3 dir,
     float maxDistance,
-    entityid_t ignore,
+    const RaycastSettings& settings
-    bool solidOnly
 ) {
     Ray ray(start, dir);
     auto view = registry->view<EntityId, Transform, Rigidbody>();
@@ -176,10 +175,18 @@ std::optional<Entities::RaycastResult> Entities::rayCast(
     glm::ivec3 foundNormal;
 
     for (auto [entity, eid, transform, body] : view.each()) {
-        if (eid.uid == ignore || !body.enabled || (solidOnly && !eid.def.solid)) {
+        if (eid.uid == settings.ignoredUid || !body.enabled ||
+            (settings.solidEntitiesOnly && !eid.def.solid)) {
             continue;
         }
-        auto& hitbox = body.hitbox;
+        if (settings.entitiesFilter) {
+            bool matches = settings.entitiesFilter->find(eid.def.rt.id) !=
+                           settings.entitiesFilter->end();
+            if (matches == settings.entityFilterExcludeMode) {
+                continue;
+            }
+        }
+        const auto& hitbox = body.hitbox;
         glm::ivec3 normal;
         double distance;
         if (ray.intersectAABB(

src/objects/Entities.hpp

@@ -5,6 +5,7 @@
 #include <optional>
 #include <vector>
 
+#include "constants.hpp"
 #include "physics/Hitbox.hpp"
 #include "Transform.hpp"
 #include "Rigidbody.hpp"
@@ -46,12 +47,6 @@ class Entities final {
     );
     void preparePhysics(float delta);
 public:
-    struct RaycastResult {
-        entityid_t entity;
-        glm::ivec3 normal;
-        float distance;
-    };
-
     Entities(Level& level);
 
     ~Entities();
@@ -82,20 +77,33 @@ public:
 
     std::optional<Entity> get(entityid_t id);
 
+    struct RaycastSettings {
+        /// @param ignore Ignored entity uid
+        entityid_t ignoredUid;
+        /// @param solidEntitiesOnly If true, only entities with solid hitboxes 
+        /// will be checked
+        bool solidEntitiesOnly = false;
+        bool entityFilterExcludeMode = false;
+        const std::set<entitydefid_t>* entitiesFilter = nullptr;
+    };
+
+    struct RaycastResult {
+        entityid_t entity;
+        glm::ivec3 normal;
+        float distance;
+    };
+
     /// @brief Entities raycast. No blocks check included, use combined with
     /// Chunks.rayCast
     /// @param start Ray start
     /// @param dir Ray direction normalized vector
     /// @param maxDistance Max ray length
-    /// @param ignore Ignored entity ID
-    /// @param solidOnly If true, only entities with solid hitboxes will be checked
     /// @return An optional structure containing entity, normal and distance
     std::optional<RaycastResult> rayCast(
         glm::vec3 start,
         glm::vec3 dir,
         float maxDistance,
-        entityid_t ignore = -1,
+        const RaycastSettings& settings
-        bool solidOnly = false
     );
 
     void loadEntities(dv::value map);

src/voxels/Chunks.cpp

@@ -215,11 +215,10 @@ voxel* Chunks::rayCast(
     glm::vec3& end,
     glm::ivec3& norm,
     glm::ivec3& iend,
-    std::set<blockid_t> filter,
+    const blocks_agent::RaycastSettings& settings
-    bool includeNonSelectable
 ) const {
     return blocks_agent::raycast(
-        *this, start, dir, maxDist, end, norm, iend, std::move(filter), includeNonSelectable
+        *this, start, dir, maxDist, end, norm, iend, settings
     );
 }
 

src/voxels/Chunks.hpp

@@ -24,6 +24,10 @@ class VoxelsVolume;
 
 template <int w, int h, int d> class StaticVoxelsVolume;
 
+namespace blocks_agent {
+    struct RaycastSettings;
+}
+
 /// Player-centred chunks matrix
 class Chunks {
     LevelEvents* events;
@@ -112,8 +116,7 @@ public:
         glm::vec3& end,
         glm::ivec3& norm,
         glm::ivec3& iend,
-        std::set<blockid_t> filter = {},
+        const blocks_agent::RaycastSettings& settings
-        bool includeNonSelectable = false
     ) const;
 
     glm::vec3 rayCastToObstacle(

src/voxels/blocks_agent.cpp

@@ -223,8 +223,7 @@ static inline voxel* raycast_blocks(
     glm::vec3& end,
     glm::ivec3& norm,
     glm::ivec3& iend,
-    std::set<blockid_t> filter,
+    const RaycastSettings& settings
-    bool includeNonSelectable
 ) {
     const auto& blocks = chunks.getContentIndices().blocks;
     float px = start.x;
@@ -259,16 +258,20 @@ static inline voxel* raycast_blocks(
     float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity;
 
     int steppedIndex = -1;
-
+    bool includeNonSelectable = settings.includeNonSelectable;
+    
     while (t <= maxDist) {
         voxel* voxel = get(chunks, ix, iy, iz);
         if (voxel == nullptr) {
             return nullptr;
         }
 
+        auto filter = settings.filter;
         const auto& def = blocks.require(voxel->id);
-        if (voxel->id != BLOCK_AIR && (def.selectable || includeNonSelectable) &&
+        if (voxel->id != BLOCK_AIR
-            (filter.empty() || filter.find(def.rt.id) == filter.end())) {
+            && (def.selectable || includeNonSelectable) 
+            && (filter == nullptr || filter->empty() ||
+             filter->find(def.rt.id) == filter->end())) {
             end.x = px + t * dx;
             end.y = py + t * dy;
             end.z = pz + t * dz;
@@ -365,10 +368,9 @@ voxel* blocks_agent::raycast(
     glm::vec3& end,
     glm::ivec3& norm,
     glm::ivec3& iend,
-    std::set<blockid_t> filter,
+    const RaycastSettings& settings
-    bool includeNonSelectable
 ) {
-    return raycast_blocks(chunks, start, dir, maxDist, end, norm, iend, filter, includeNonSelectable);
+    return raycast_blocks(chunks, start, dir, maxDist, end, norm, iend, settings);
 }
 
 voxel* blocks_agent::raycast(
@@ -379,10 +381,9 @@ voxel* blocks_agent::raycast(
     glm::vec3& end,
     glm::ivec3& norm,
     glm::ivec3& iend,
-    std::set<blockid_t> filter,
+    const RaycastSettings& settings
-    bool includeNonSelectable
 ) {
-    return raycast_blocks(chunks, start, dir, maxDist, end, norm, iend, filter, includeNonSelectable);
+    return raycast_blocks(chunks, start, dir, maxDist, end, norm, iend, settings);
 }
 
 // reduce nesting on next modification

src/voxels/blocks_agent.hpp

@@ -412,6 +412,11 @@ inline void set_rotation(
     }
 }
 
+struct RaycastSettings {
+    const std::set<blockid_t>* filter = nullptr;
+    bool includeNonSelectable = false;
+};
+
 /// @brief Cast ray to a selectable block with filter based on id.
 /// @param chunks chunks matrix
 /// @param start ray start position
@@ -431,8 +436,7 @@ voxel* raycast(
     glm::vec3& end,
     glm::ivec3& norm,
     glm::ivec3& iend,
-    std::set<blockid_t> filter,
+    const RaycastSettings& settings
-    bool includeNonSelectable
 );
 
 /// @brief Cast ray to a selectable block with filter based on id.
@@ -454,8 +458,7 @@ voxel* raycast(
     glm::vec3& end,
     glm::ivec3& norm,
     glm::ivec3& iend,
-    std::set<blockid_t> filter,
+    const RaycastSettings& settings
-    bool includeNonSelectable
 );
 
 void get_voxels(