system.hpp

Go to the documentation of this file.

 
#ifndef TOYMAKERENGINE_SPATIALQUERYSYSTEM_H
#define TOYMAKERENGINE_SPATIALQUERYSYSTEM_H
 
#include <memory>
 
#include "octree.hpp"
#include "../scene_system.hpp"
#include "../core/ecs_world.hpp"
#include "../model.hpp"
#include "../light.hpp"
 
namespace ToyMaker {

    class SpatialQuerySystem: public System<SpatialQuerySystem, std::tuple<Transform, ObjectBounds>, std::tuple<AxisAlignedBounds>> {
    public:
        explicit SpatialQuerySystem(std::weak_ptr<ECSWorld> world):
        System<SpatialQuerySystem, std::tuple<Transform, ObjectBounds>, std::tuple<AxisAlignedBounds>>{ world }
        {}

        static std::string getSystemTypeName() { return "SpatialQuerySystem"; }

        class StaticModelBoundsComputeSystem: public System<StaticModelBoundsComputeSystem, std::tuple<std::shared_ptr<StaticModel>, Transform, ObjectBounds>, std::tuple<>> {
        public:
 
            explicit StaticModelBoundsComputeSystem(std::weak_ptr<ECSWorld> world):
            System<SpatialQuerySystem::StaticModelBoundsComputeSystem, std::tuple<std::shared_ptr<StaticModel>, Transform, ObjectBounds>, std::tuple<>> { world }
            {}

            static std::string getSystemTypeName() { return "SpatialQuerySystem::StaticModelBoundsComputeSystem"; }
 
        private:

            void onEntityEnabled(EntityID entityID) override;

            void onEntityUpdated(EntityID entityID, ComponentType updatedComponent) override;

            void recomputeObjectBounds(EntityID entityID);
        };

        class LightBoundsComputeSystem: public System<LightBoundsComputeSystem, std::tuple<LightEmissionData, ObjectBounds>, std::tuple<>> {
 
        public:
 
            explicit LightBoundsComputeSystem(std::weak_ptr<ECSWorld> world):
            System<SpatialQuerySystem::LightBoundsComputeSystem, std::tuple<LightEmissionData, ObjectBounds>, std::tuple<>>{world}
            {}

            static std::string getSystemTypeName() { return "SpatialQuerySystem::LightBoundsComputeSystem"; }
 
        private:

            void onEntityEnabled(EntityID entityID) override;

            void onEntityUpdated(EntityID entityID, ComponentType updatedComponent) override;

            void recomputeObjectBounds(EntityID entityID);
        };

        std::vector<std::pair<EntityID, AxisAlignedBounds>> findEntitiesOverlappingCoarse(const AxisAlignedBounds& searchBounds, InteractionLayerMask interactionMask=std::numeric_limits<InteractionLayerMask>::max()) const;

        std::vector<std::pair<EntityID, AxisAlignedBounds>> findEntitiesOverlappingCoarse(const Ray& ray, InteractionLayerMask interactionMask=std::numeric_limits<InteractionLayerMask>::max()) const;

        std::vector<std::shared_ptr<SceneNodeCore>> findNodesOverlappingCoarse(const Ray& searchRay, InteractionLayerMask interactionMask=std::numeric_limits<InteractionLayerMask>::max());

        std::vector<std::shared_ptr<SceneNodeCore>> findNodesOverlappingCoarse(const AxisAlignedBounds& searchBounds, InteractionLayerMask interactionMask=std::numeric_limits<InteractionLayerMask>::max());

        void updateBoundingVolume(
            EntityID entity,
            ObjectBounds::TrueVolumeType volumeType,
            const ObjectBounds::TrueVolume& volume,
            const glm::vec3& positionOffset,
            const glm::quat& orientationOffset
        );

        inline void updateBounds(
            const std::shared_ptr<SceneNodeCore>& sceneNode,
            ObjectBounds::TrueVolumeType volumeType,
            const ObjectBounds::TrueVolume& volume,
            const glm::vec3& positionOffset,
            const glm::quat& orientationOffset
        ) {
            assert(sceneNode && "Scene node pointer cannot be nullptr");
            updateBoundingVolume(sceneNode->getEntityID(),
                volumeType, volume,
                positionOffset, orientationOffset
            );
        };

        void resetBoundsOverride(
            EntityID entity
        );
 
    private:
        void updateBounds(EntityID entity, bool forceUpdateFromTransform=false);

        void updateTransform(EntityID entity);

        void rebuildOctree();

        void onSimulationActivated() override;

        void onSimulationPostStep(uint32_t timestepMillis) override;

        void onPostTransformUpdate(uint32_t timestepMillis) override;

        void onEntityEnabled(EntityID entityID) override;

        void onEntityDisabled(EntityID entityID) override;

        void onEntityUpdated(EntityID entityID, ComponentType updatedComponent) override;

        std::unique_ptr<Octree> mOctree { nullptr };

        std::set<EntityID> mUpdateQueueAABB {};

        std::set<EntityID> mUpdateQueueTransform {};

        bool mRequiresInitialization { true };
    };
 
    // Prevent enabling and disabling of spatial query related systems, leave their management entirely to
    // the scene system
    template <>
    inline void SceneNodeCore::setEnabled<SpatialQuerySystem>(bool) {/* pass */}
    template <>
    inline void SceneNodeCore::setEnabled<SpatialQuerySystem::LightBoundsComputeSystem>(bool) {/* pass */}
    template <>
    inline void SceneNodeCore::setEnabled<SpatialQuerySystem::StaticModelBoundsComputeSystem>(bool) {/* pass */}
 
    template <>
    inline void SceneNodeCore::updateComponent<AxisAlignedBounds>(const AxisAlignedBounds& axisAlignedBoxBounds) {
        (void)axisAlignedBoxBounds; // prevent unused parameter warnings
        assert(false && "Cannot update a scene node's WorldBounds component");
    }
    template<>
    inline void SceneNodeCore::updateComponent<ObjectBounds>(const ObjectBounds& objectBounds) {
        (void)objectBounds; // prevent unused parameter warnings
        assert(false && "Cannot update a scene node's ObjectBounds component");
    }
    template <>
    inline void SceneNodeCore::removeComponent<AxisAlignedBounds>() {
        assert(false && "Cannot remove a scene node's AABBTreeNode component");
    }
    template <>
    inline void SceneNodeCore::removeComponent<ObjectBounds>() {
        assert(false && "Cannot remove a scene node's ObjectBounds component");
    }
}
 
#endif