////  EntityTreeElement.h//  libraries/entities/src////  Created by Brad Hefta-Gaub on 12/4/13.//  Copyright 2013 High Fidelity, Inc.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html// #ifndef hifi_EntityTreeElement_h#define hifi_EntityTreeElement_h #include <memory> #include <OctreeElement.h>#include <QList> #include "EntityEditPacketSender.h"#include "EntityItem.h" #include <PickFilter.h> class EntityTree;class EntityTreeElement; using EntityItems = QVector<EntityItemPointer>;using EntityTreeElementWeakPointer = std::weak_ptr<EntityTreeElement>;using EntityTreeElementPointer = std::shared_ptr<EntityTreeElement>;using EntityItemFilter = std::function<bool(EntityItemPointer&)>; class EntityTreeUpdateArgs {public:    EntityTreeUpdateArgs() :            _totalElements(0),            _totalItems(0),            _movingItems(0)    { }     QList<EntityItemPointer> _movingEntities;    int _totalElements;    int _totalItems;    int _movingItems;}; class EntityTreeElementExtraEncodeData : public OctreeElementExtraEncodeDataBase {public:    EntityTreeElementExtraEncodeData() :        elementCompleted(false),        subtreeCompleted(false),        entities() {            memset(childCompleted, 0, sizeof(childCompleted));        }    bool elementCompleted;    bool subtreeCompleted;    bool childCompleted[NUMBER_OF_CHILDREN];    QMap<EntityItemID, EntityPropertyFlags> entities;};using EntityTreeElementExtraEncodeDataPointer = std::shared_ptr<EntityTreeElementExtraEncodeData>; inline QDebug operator<<(QDebug debug, const EntityTreeElementExtraEncodeDataPointer data) {    debug << "{";    debug << " elementCompleted: " << data->elementCompleted << ", ";    debug << " subtreeCompleted: " << data->subtreeCompleted << ", ";    debug << " childCompleted[]: ";    for (int i = 0; i < NUMBER_OF_CHILDREN; i++) {        debug << " " << i << ":" << data->childCompleted[i] << ", ";    }    debug << " entities.size: " << data->entities.size() << "}";    return debug;}  class SendModelsOperationArgs {public:    glm::vec3 root;    EntityEditPacketSender* packetSender;}; class EntityTreeElement : public OctreeElement, ReadWriteLockable {    friend class EntityTree; // to allow createElement to new us...     EntityTreeElement(unsigned char* octalCode = NULL);     virtual OctreeElementPointer createNewElement(unsigned char* octalCode = NULL) override; public:    virtual ~EntityTreeElement();     // type safe versions of OctreeElement methods    EntityTreeElementPointer getChildAtIndex(int index) const {        return std::static_pointer_cast<EntityTreeElement>(OctreeElement::getChildAtIndex(index));    }     // methods you can and should override to implement your tree functionality     /// Adds a child to the current element. Override this if there is additional child initialization your class needs.    virtual OctreeElementPointer addChildAtIndex(int index) override;     /// Override this to implement LOD averaging on changes to the tree.    virtual void calculateAverageFromChildren() override;     /// Override this to implement LOD collapsing and identical child pruning on changes to the tree.    virtual bool collapseChildren() override;     /// Should this element be considered to have content in it. This will be used in collision and ray casting methods.    /// By default we assume that only leaves are actual content, but some octrees may have different semantics.    virtual bool hasContent() const override { return hasEntities(); }     /// Should this element be considered to have detailed content in it. Specifically should it be rendered.    /// By default we assume that only leaves have detailed content, but some octrees may have different semantics.    virtual bool hasDetailedContent() const override { return hasEntities(); }     /// Override this to break up large octree elements when an edit operation is performed on a smaller octree element.    /// For example, if the octrees represent solid cubes and a delete of a smaller octree element is done then the    /// meaningful split would be to break the larger cube into smaller cubes of the same color/texture.    virtual void splitChildren() override { }     /// Override to indicate that this element requires a split before editing lower elements in the octree    virtual bool requiresSplit() const override { return false; }     virtual void debugExtraEncodeData(EncodeBitstreamParams& params) const override;     /// Override to deserialize the state of this element. This is used for loading from a persisted file or from reading    /// from the network.    virtual int readElementDataFromBuffer(const unsigned char* data, int bytesLeftToRead,                                          ReadBitstreamToTreeParams& args) override;     /// Override to indicate that the item is currently rendered in the rendering engine. By default we assume that if    /// the element should be rendered, then your rendering engine is rendering. But some rendering engines my have cases    /// where an element is not actually rendering all should render elements. If the isRendered() state doesn't match the    /// shouldRender() state, the tree will remark elements as changed even in cases there the elements have not changed.    virtual bool isRendered() const override { return getShouldRender(); }    virtual bool deleteApproved() const override { return !hasEntities(); }     static bool checkFilterSettings(const EntityItemPointer& entity, PickFilter searchFilter);    virtual bool canPickIntersect() const override { return hasEntities(); }    virtual EntityItemID evalRayIntersection(const glm::vec3& origin, const glm::vec3& direction, const glm::vec3& viewFrustumPos,        OctreeElementPointer& element, float& distance, BoxFace& face, glm::vec3& surfaceNormal,        const QVector<EntityItemID>& entityIdsToInclude, const QVector<EntityItemID>& entityIdsToDiscard,        PickFilter searchFilter, QVariantMap& extraInfo);    virtual EntityItemID evalDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,                         const glm::vec3& viewFrustumPos, OctreeElementPointer& element, float& distance,                         BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude,                         const QVector<EntityItemID>& entityIdsToDiscard, PickFilter searchFilter, QVariantMap& extraInfo);    virtual bool findSpherePenetration(const glm::vec3& center, float radius,                        glm::vec3& penetration, void** penetratedObject) const override;     virtual EntityItemID evalParabolaIntersection(const glm::vec3& origin, const glm::vec3& velocity,        const glm::vec3& acceleration, const glm::vec3& viewFrustumPos, OctreeElementPointer& element, float& parabolicDistance,        BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude,        const QVector<EntityItemID>& entityIdsToDiscard, PickFilter searchFilter, QVariantMap& extraInfo);    virtual EntityItemID evalDetailedParabolaIntersection(const glm::vec3& origin, const glm::vec3& velocity,        const glm::vec3& normal, const glm::vec3& acceleration, const glm::vec3& viewFrustumPos, OctreeElementPointer& element,        float& parabolicDistance, BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude,        const QVector<EntityItemID>& entityIdsToDiscard, PickFilter searchFilter, QVariantMap& extraInfo);     template <typename F>    void forEachEntity(F f) const {        withReadLock([&] {            foreach(EntityItemPointer entityItem, _entityItems) {                f(entityItem);            }        });    }     virtual uint16_t size() const;    bool hasEntities() const { return size() > 0; }     void setTree(EntityTreePointer tree) { _myTree = tree; }    EntityTreePointer getTree() const { return _myTree; }     void addEntityItem(EntityItemPointer entity);     QUuid evalClosetEntity(const glm::vec3& position, PickFilter searchFilter, float& closestDistanceSquared) const;    void evalEntitiesInSphere(const glm::vec3& position, float radius, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;    void evalEntitiesInSphereWithType(const glm::vec3& position, float radius, EntityTypes::EntityType type, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;    void evalEntitiesInSphereWithName(const glm::vec3& position, float radius, const QString& name, bool caseSensitive, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;    void evalEntitiesInSphereWithTags(const glm::vec3& position, float radius, const QVector<QString>& tags, bool caseSensitive, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;    void evalEntitiesInCube(const AACube& cube, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;    void evalEntitiesInBox(const AABox& box, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;    void evalEntitiesInFrustum(const ViewFrustum& frustum, PickFilter searchFilter, QVector<QUuid>& foundEntities) const;     /// finds all entities that match filter    /// \param filter function that adds matching entities to foundEntities    /// \param entities[out] vector of non-const EntityItemPointer    void getEntities(EntityItemFilter& filter,  QVector<EntityItemPointer>& foundEntities);     EntityItemPointer getEntityWithID(uint32_t id) const;    EntityItemPointer getEntityWithEntityItemID(const EntityItemID& id) const;    void getEntitiesInside(const AACube& box, QVector<EntityItemPointer>& foundEntities);     void cleanupDomainAndNonOwnedEntities();    void cleanupEntities(); /// called by EntityTree on cleanup this will free all entities    bool removeEntityItem(EntityItemPointer entity, bool deletion = false);     bool containsEntityBounds(EntityItemPointer entity) const;    bool bestFitEntityBounds(EntityItemPointer entity) const;     bool containsBounds(const EntityItemProperties& properties) const; // NOTE: property units in meters    bool bestFitBounds(const EntityItemProperties& properties) const; // NOTE: property units in meters     bool containsBounds(const AACube& bounds) const; // NOTE: units in tree units    bool bestFitBounds(const AACube& bounds) const; // NOTE: units in tree units     bool containsBounds(const AABox& bounds) const; // NOTE: units in tree units    bool bestFitBounds(const AABox& bounds) const; // NOTE: units in tree units     bool containsBounds(const glm::vec3& minPoint, const glm::vec3& maxPoint) const; // NOTE: units in tree units    bool bestFitBounds(const glm::vec3& minPoint, const glm::vec3& maxPoint) const; // NOTE: units in tree units     void debugDump();     bool pruneChildren();     void expandExtentsToContents(Extents& extents);     EntityTreeElementPointer getThisPointer() {        return std::static_pointer_cast<EntityTreeElement>(shared_from_this());    }    OctreeElementPointer getThisOctreeElementPointer() {        return std::static_pointer_cast<OctreeElement>(shared_from_this());    }    const ConstOctreeElementPointer getConstThisOctreeElementPointer() const {        return std::static_pointer_cast<const OctreeElement>(shared_from_this());    } protected:    virtual void init(unsigned char * octalCode) override;    EntityTreePointer _myTree;    EntityItems _entityItems;}; #endif // hifi_EntityTreeElement_h