refactor: use CollisionLayer enum instead of string comparisons

Author: LoayAhmed304

src/game/components/collider.cpp

@@ -6,15 +6,24 @@ static gameplay::ColliderShape parseColliderShape(const std::string& value, game
     return fallback;
 }
 
+static inline gameplay::CollisionLayer layerStringToGroup(const std::string& layer) {
+    if (layer == "player") return gameplay::CollisionLayer::LAYER_PLAYER;
+    if (layer == "enemy") return gameplay::CollisionLayer::LAYER_ENEMY;
+    if (layer == "projectile") return gameplay::CollisionLayer::LAYER_PROJECTILE;
+    if (layer == "trigger") return gameplay::CollisionLayer::LAYER_TRIGGER;
+    return gameplay::CollisionLayer::LAYER_ENVIRONMENT;  // environment is the default layer
+}
+
 namespace gameplay {
 
     void ColliderComponent::deserialize(const nlohmann::json& data) {
         if (!data.is_object()) return;
         shape = parseColliderShape(data.value("shape", std::string("Sphere")), shape);
-        layer = data.value("layer", layer);
         radius = data.value("radius", radius);
         height = data.value("height", height);
         isTrigger = data.value("isTrigger", isTrigger);
+        std::string stringLayer = data.value("layer", "");
+        layer = layerStringToGroup(stringLayer);
     }
 
 }  // namespace gameplay

src/game/components/collider.hpp

@@ -6,10 +6,18 @@ namespace gameplay {
 
     enum class ColliderShape { Sphere, Capsule };
 
+    enum CollisionLayer : short {
+        LAYER_PLAYER = 1 << 0,       // bit 0:  0000 0001
+        LAYER_ENEMY = 1 << 1,        // bit 1:  0000 0010
+        LAYER_ENVIRONMENT = 1 << 2,  // bit 2:  0000 0100
+        LAYER_PROJECTILE = 1 << 3,   // bit 3:  0000 1000
+        LAYER_TRIGGER = 1 << 4,      // bit 4:  0001 0000
+    };
+
     class ColliderComponent : public our::Component {
     public:
         ColliderShape shape = ColliderShape::Sphere;
-        std::string layer = "default";
+        CollisionLayer layer = CollisionLayer::LAYER_ENVIRONMENT;
         float radius = 0.5f;
         float height = 1.0f;  // must be the total height
         bool isTrigger = false;

src/game/systems/collision-system.cpp

@@ -37,15 +37,6 @@ static btTransform entityToBtTransform(our::Entity* entity) {
 
 namespace gameplay {
 
-    inline short layerStringToGroup(const std::string& layer) {
-        if (layer == "player") return CollisionLayer::LAYER_PLAYER;
-        if (layer == "enemy") return CollisionLayer::LAYER_ENEMY;
-        if (layer == "environment") return CollisionLayer::LAYER_ENVIRONMENT;
-        if (layer == "projectile") return CollisionLayer::LAYER_PROJECTILE;
-        if (layer == "trigger") return CollisionLayer::LAYER_TRIGGER;
-        return 0;  // default to no layer
-    }
-
     inline short getMaskForLayer(short group) {
         switch (group) {
             case LAYER_PLAYER:
@@ -179,9 +170,9 @@ namespace gameplay {
             if (colliderA->isTrigger || colliderB->isTrigger) continue;
 
             // push back logic (don't push environments)
-            if (colliderA->layer == "environment") {
+            if (colliderA->layer == CollisionLayer::LAYER_ENVIRONMENT) {
                 event.entityB->localTransform.position -= event.normal * event.penetrationDepth;
-            } else if (colliderB->layer == "environment") {
+            } else if (colliderB->layer == CollisionLayer::LAYER_ENVIRONMENT) {
                 event.entityA->localTransform.position += event.normal * event.penetrationDepth;
             } else {  // this may be edited or removed later
                 event.entityA->localTransform.position -= event.normal * (event.penetrationDepth / 2.0f);
@@ -191,18 +182,17 @@ namespace gameplay {
     }
 
     // On-demand function
-    HitInfo CollisionSystem::raycast(const Ray& ray, float maxDistance, const std::string targetLayer) const {
+    HitInfo CollisionSystem::raycast(const Ray& ray, float maxDistance, const short targetLayer) const {
         HitInfo hitInfo;
 
         if (!collisionWorld) return hitInfo;
         btVector3 from = glmToBtVec3(ray.origin);
         btVector3 to = glmToBtVec3(ray.origin + ray.direction * maxDistance);
 
         btCollisionWorld::ClosestRayResultCallback callback(from, to);
-        if (!targetLayer.empty()) {
-            callback.m_collisionFilterGroup = btBroadphaseProxy::AllFilter;    // check against all layers
-            callback.m_collisionFilterMask = layerStringToGroup(targetLayer);  // only collide with the target layer
-        }
+
+        callback.m_collisionFilterGroup = btBroadphaseProxy::AllFilter;  // check against all layers
+        callback.m_collisionFilterMask = targetLayer;                    // only collide with the target layer
 
         collisionWorld->rayTest(from, to, callback);
 
@@ -218,21 +208,13 @@ namespace gameplay {
     }
 
     // On-demand function
-    std::vector<our::Entity*> CollisionSystem::overlapSphere(const glm::vec3& center, float radius,
-                                                             std::string targetLayer) {
+    std::vector<our::Entity*> CollisionSystem::overlapSphere(const glm::vec3& center, float radius, short targetLayer) {
         std::vector<our::Entity*> results;
         if (!collisionWorld) return results;
 
-        short targetMask = 0;
-        if (!targetLayer.empty()) {
-            targetMask = layerStringToGroup(targetLayer);
-        }
-
         for (const auto& [entity, obj] : entityToBullet) {
-            if (targetMask != 0) {
-                short objGroup = obj->getBroadphaseHandle()->m_collisionFilterGroup;
-                if ((objGroup & targetMask) == 0) continue;
-            }
+            short objGroup = obj->getBroadphaseHandle()->m_collisionFilterGroup;
+            if ((objGroup & targetLayer) == 0) continue;
 
             glm::vec3 entityPos = btToGlmVec3(obj->getWorldTransform().getOrigin());
 
@@ -276,12 +258,12 @@ namespace gameplay {
         obj->setUserPointer(entity);  // so we can go back to the entity
 
         // Mark non-environment objects as KINEMATIC.
-        if (collider->layer != "environment") {
+        if (collider->layer != CollisionLayer::LAYER_ENVIRONMENT) {
             obj->setCollisionFlags(obj->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
         }
 
         // Add to Bullet world with layer filtering
-        short group = layerStringToGroup(collider->layer);
+        short group = collider->layer;
         short mask = getMaskForLayer(group);
         collisionWorld->addCollisionObject(obj, group, mask);
         entityToBullet[entity] = obj;

src/game/systems/collision-system.hpp

@@ -39,15 +39,6 @@ namespace gameplay {
         float penetrationDepth = 0.0f;  // how much the two colliders are penetrating each other
     };
 
-    enum CollisionLayer : short {
-        LAYER_PLAYER = 1 << 0,       // bit 0:  0000 0001
-        LAYER_ENEMY = 1 << 1,        // bit 1:  0000 0010
-        LAYER_ENVIRONMENT = 1 << 2,  // bit 2:  0000 0100
-        LAYER_PROJECTILE = 1 << 3,   // bit 3:  0000 1000
-        LAYER_TRIGGER = 1 << 4,      // bit 4:  0001 0000
-    };
-
-    short layerStringToGroup(const std::string& layer);
     short getMaskForLayer(short group);
 
     class CollisionSystem {
@@ -77,10 +68,11 @@ namespace gameplay {
         void update(our::World* world);
 
         // On-demand raycast function that can be used outside of the update loop to query the world for collisions.
-        HitInfo raycast(const Ray& ray, float maxDistance, const std::string targetLayer = "") const;
+        HitInfo raycast(const Ray& ray, float maxDistance,
+                        const short targetLayer = CollisionLayer::LAYER_ENVIRONMENT) const;
 
         // On-demand overlap sphere function that can be used outside of the update loop
-        std::vector<our::Entity*> overlapSphere(const glm::vec3& center, float radius, std::string targetLayer = "");
+        std::vector<our::Entity*> overlapSphere(const glm::vec3& center, float radius, short targetLayer);
 
         const std::vector<CollisionEvent>& getCollisions() const;
     };