////  AvatarHashMap.h//  libraries/avatars/src////  Created by Andrew Meadows on 1/28/2014.//  Copyright 2014 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_AvatarHashMap_h#define hifi_AvatarHashMap_h #include <QtCore/QHash>#include <QtCore/QSharedPointer>#include <QtCore/QUuid> #include <functional>#include <memory>#include <chrono> #include <glm/glm.hpp> #include <DependencyManager.h>#include <NLPacket.h>#include <Node.h> #include "ScriptAvatarData.h" #include "AvatarData.h"#include "AssociatedTraitValues.h" const int CLIENT_TO_AVATAR_MIXER_BROADCAST_FRAMES_PER_SECOND = 50;const quint64 MIN_TIME_BETWEEN_MY_AVATAR_DATA_SENDS = USECS_PER_SECOND / CLIENT_TO_AVATAR_MIXER_BROADCAST_FRAMES_PER_SECOND; /*@jsdoc * The <code>AvatarList</code> API provides information about avatars within the current domain. * * <p><strong>Warning:</strong> An API named "<code>AvatarList</code>" is also provided for Interface, client entity, and avatar  * scripts, however, it is a synonym for the {@link AvatarManager} API.</p> * * @namespace AvatarList * * @hifi-assignment-client * @hifi-server-entity */ class AvatarReplicas {public:    AvatarReplicas() {}    void addReplica(const QUuid& parentID, AvatarSharedPointer replica);    std::vector<QUuid> getReplicaIDs(const QUuid& parentID);    void parseDataFromBuffer(const QUuid& parentID, const QByteArray& buffer);    void processAvatarIdentity(const QUuid& parentID, const QByteArray& identityData, bool& identityChanged, bool& displayNameChanged);    void removeReplicas(const QUuid& parentID);    std::vector<AvatarSharedPointer> takeReplicas(const QUuid& parentID);    void processTrait(const QUuid& parentID, AvatarTraits::TraitType traitType, QByteArray traitBinaryData);    void processDeletedTraitInstance(const QUuid& parentID, AvatarTraits::TraitType traitType, AvatarTraits::TraitInstanceID instanceID);    void processTraitInstance(const QUuid& parentID, AvatarTraits::TraitType traitType,                                AvatarTraits::TraitInstanceID instanceID, QByteArray traitBinaryData);    void setReplicaCount(int count) { _replicaCount = count; }    int getReplicaCount() { return _replicaCount; } private:    std::map<QUuid, std::vector<AvatarSharedPointer>> _replicasMap;    int _replicaCount { 0 };};  class AvatarHashMap : public QObject, public Dependency {    Q_OBJECT    SINGLETON_DEPENDENCY public:    AvatarHash getHashCopy() { QReadLocker lock(&_hashLock); return _avatarHash; }    const AvatarHash getHashCopy() const { QReadLocker lock(&_hashLock); return _avatarHash; }    int size() { QReadLocker lock(&_hashLock); return _avatarHash.size(); }     // Currently, your own avatar will be included as the null avatar id.        /*@jsdoc     * Gets the IDs of all avatars in the domain.     * <p><strong>Warning:</strong> If the AC script is acting as an avatar (i.e., <code>Agent.isAvatar == true</code>) the      * avatar's ID is NOT included in results.</p>     * @function AvatarList.getAvatarIdentifiers     * @returns {Uuid[]} The IDs of all avatars in the domain (excluding AC script's avatar).     * @example <caption>Report the IDS of all avatars within the domain.</caption>     * var avatars = AvatarList.getAvatarIdentifiers();     * print("Avatars in the domain: " + JSON.stringify(avatars));     */    Q_INVOKABLE QVector<QUuid> getAvatarIdentifiers();     /*@jsdoc     * Gets the IDs of all avatars within a specified distance from a point.     * <p><strong>Warning:</strong> If the AC script is acting as an avatar (i.e., <code>Agent.isAvatar == true</code>) the     * avatar's ID is NOT included in results.</p>     * @function AvatarList.getAvatarsInRange     * @param {Vec3} position - The point about which the search is performed.     * @param {number} range - The search radius.     * @returns {Uuid[]} The IDs of all avatars within the search distance from the position (excluding AC script's avatar).     * @example <caption>Report the IDs of all avatars within 10m of the origin.</caption>     * var RANGE = 10;     * var avatars = AvatarList.getAvatarsInRange(Vec3.ZERO, RANGE);     * print("Avatars near the origin: " + JSON.stringify(avatars));     */    Q_INVOKABLE QVector<QUuid> getAvatarsInRange(const glm::vec3& position, float rangeMeters) const;     /*@jsdoc     * Gets information about an avatar.     * @function AvatarList.getAvatar     * @param {Uuid} avatarID - The ID of the avatar.     * @returns {ScriptAvatar} Information about the avatar.     */    // Null/Default-constructed QUuids will return MyAvatar    Q_INVOKABLE virtual ScriptAvatarData* getAvatar(QUuid avatarID) { return new ScriptAvatarData(getAvatarBySessionID(avatarID)); }     virtual AvatarSharedPointer getAvatarBySessionID(const QUuid& sessionID) const { return findAvatar(sessionID); }    int numberOfAvatarsInRange(const glm::vec3& position, float rangeMeters);     void setReplicaCount(int count);    int getReplicaCount() { return _replicas.getReplicaCount(); };     virtual void clearOtherAvatars(); signals:     /*@jsdoc     * Triggered when an avatar arrives in the domain.     * @function AvatarList.avatarAddedEvent     * @param {Uuid} sessionUUID - The ID of the avatar that arrived in the domain.     * @returns {Signal}     * @example <caption>Report when an avatar arrives in the domain.</caption>     * AvatarManager.avatarAddedEvent.connect(function (sessionID) {     *     print("Avatar arrived: " + sessionID);     * });     *     * // Note: If using from the AvatarList API, replace "AvatarManager" with "AvatarList".     */    void avatarAddedEvent(const QUuid& sessionUUID);     /*@jsdoc     * Triggered when an avatar leaves the domain.     * @function AvatarList.avatarRemovedEvent     * @param {Uuid} sessionUUID - The ID of the avatar that left the domain.     * @returns {Signal}     * @example <caption>Report when an avatar leaves the domain.</caption>     * AvatarManager.avatarRemovedEvent.connect(function (sessionID) {     *     print("Avatar left: " + sessionID);     * });     *     * // Note: If using from the AvatarList API, replace "AvatarManager" with "AvatarList".     */    void avatarRemovedEvent(const QUuid& sessionUUID);     /*@jsdoc     * Triggered when an avatar's session ID changes.     * @function AvatarList.avatarSessionChangedEvent     * @param {Uuid} newSessionUUID - The new session ID.     * @param {Uuid} oldSessionUUID - The old session ID.     * @returns {Signal}     * @example <caption>Report when an avatar's session ID changes.</caption>     * AvatarManager.avatarSessionChangedEvent.connect(function (newSessionID, oldSessionID) {     *     print("Avatar session ID changed from " + oldSessionID + " to " + newSessionID);     * });     *     * // Note: If using from the AvatarList API, replace "AvatarManager" with "AvatarList".     */    void avatarSessionChangedEvent(const QUuid& sessionUUID,const QUuid& oldUUID); public slots:     /*@jsdoc     * Checks whether there is an avatar within a specified distance from a point.     * @function AvatarList.isAvatarInRange     * @param {string} position - The test position.     * @param {string} range - The test distance.     * @returns {boolean} <code>true</code> if there's an avatar within the specified distance of the point, <code>false</code>      *     if not.     */    bool isAvatarInRange(const glm::vec3 & position, const float range); protected slots:     /*@jsdoc     * @function AvatarList.sessionUUIDChanged     * @param {Uuid} sessionUUID - New session ID.     * @param {Uuid} oldSessionUUID - Old session ID.     * @deprecated This function is deprecated and will be removed.     */    void sessionUUIDChanged(const QUuid& sessionUUID, const QUuid& oldUUID);     /*@jsdoc     * @function AvatarList.processAvatarDataPacket     * @param {object} message - Message.     * @param {object} sendingNode - Sending node.     * @deprecated This function is deprecated and will be removed.     */    void processAvatarDataPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);       /*@jsdoc     * @function AvatarList.processAvatarIdentityPacket     * @param {object} message - Message.     * @param {object} sendingNode - Sending node.     * @deprecated This function is deprecated and will be removed.     */    void processAvatarIdentityPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);        /*@jsdoc     * @function AvatarList.processBulkAvatarTraits     * @param {object} message - Message.     * @param {object} sendingNode - Sending node.     * @deprecated This function is deprecated and will be removed.     */    void processBulkAvatarTraits(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);        /*@jsdoc     * @function AvatarList.processKillAvatar     * @param {object} message - Message.     * @param {object} sendingNode - Sending node.     * @deprecated This function is deprecated and will be removed.     */    void processKillAvatar(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode); protected:    AvatarHashMap();     virtual AvatarSharedPointer parseAvatarData(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);    virtual AvatarSharedPointer newSharedAvatar(const QUuid& sessionUUID);    virtual AvatarSharedPointer addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);    AvatarSharedPointer newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer,        bool& isNew);    virtual AvatarSharedPointer findAvatar(const QUuid& sessionUUID) const; // uses a QReadLocker on the hashLock    virtual void removeAvatar(const QUuid& sessionUUID, KillAvatarReason removalReason = KillAvatarReason::NoReason);        virtual void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason = KillAvatarReason::NoReason);        mutable QReadWriteLock _hashLock;    AvatarHash _avatarHash;     std::unordered_map<QUuid, AvatarTraits::TraitVersions> _processedTraitVersions;    AvatarReplicas _replicas; private:    QUuid _lastOwnerSessionUUID;}; #endif // hifi_AvatarHashMap_h