sweep_prune.hpp

Go to the documentation of this file.

 
#ifndef TOYMAKERENGINE_SPATIALQUERYSWEEPPRUNE_H
#define TOYMAKERENGINE_SPATIALQUERYSWEEPPRUNE_H
 
#include "types.hpp"
#include "../core/ecs_world.hpp"
 
namespace ToyMaker {
    class SweepPrune;

    class CollisionPair {
    private:
        EntityID mFirst;

        EntityID mSecond;
 
    public:
        CollisionPair(EntityID first, EntityID second): mFirst { first }, mSecond { second } {
            assert(first != second && "Entities in constraint must be distinct");
            if (second < first) {
                std::swap(mFirst, mSecond);
            }
        }

        inline EntityID first() const { return mFirst; }

        inline EntityID second() const { return mSecond; }
 
        inline bool operator < (const CollisionPair& other) const {
            return (
                mFirst < other.mFirst
                || (
                    mFirst == other.mFirst
                    && mSecond < other.mSecond
               )
            );
        }
    };

    class SweepPrune {
    public:
        std::set<CollisionPair> getCollisionPairs();

        void addObject(EntityID entity, const AxisAlignedBounds& bounds);

        void removeObject(EntityID entity);

        void updateObject(EntityID entity, const AxisAlignedBounds& bounds);
 
    private:
        using EdgeIndex = std::size_t;
 
        enum Axis: uint8_t {
            X,
            Y,
            Z,
        };
        struct Object {
            std::array<std::pair<EdgeIndex, EdgeIndex>, 3> mIndices {};
        };

        struct Edge {
            EntityID mEntity;
            float mValue;
            bool mBegin;
 
            inline bool operator<(const Edge& other) {
                return (
                    mValue < other.mValue || (
                        mValue == other.mValue
                        && mEntity < other.mEntity
                        || (
                            mValue == other.mValue
                            && mEntity == other.mEntity
                            && mBegin > other.mBegin
                        )
                    )
                );
            }
        };

        void sortEdges();

        void sortEdges(Axis axis);

        void findCollisionPairs();

        std::unordered_map<EntityID, Object> mObjects {};

        std::set<CollisionPair> mCollisionPairs {};

        std::array<std::vector<Edge>, 3> mEdges {};

        std::array<std::set<CollisionPair>, 3> mOverlaps {};

        bool mRecomputeCollisions { true };
    };
}
 
#endif