mirror of
https://github.com/JulianGro/overte.git
synced 2025-08-08 00:40:49 +02:00
220 lines
11 KiB
C++
220 lines
11 KiB
C++
//
|
|
// AvatarMixerClientData.h
|
|
// assignment-client/src/avatars
|
|
//
|
|
// Created by Stephen Birarda on 2/4/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_AvatarMixerClientData_h
|
|
#define hifi_AvatarMixerClientData_h
|
|
|
|
#include <algorithm>
|
|
#include <cfloat>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
#include <queue>
|
|
|
|
#include <QtCore/QJsonObject>
|
|
#include <QtCore/QUrl>
|
|
|
|
#include <AvatarData.h>
|
|
#include <AssociatedTraitValues.h>
|
|
#include <NodeData.h>
|
|
#include <NumericalConstants.h>
|
|
#include <udt/PacketHeaders.h>
|
|
#include <PortableHighResolutionClock.h>
|
|
#include <SimpleMovingAverage.h>
|
|
#include <UUIDHasher.h>
|
|
#include <shared/ConicalViewFrustum.h>
|
|
|
|
const QString OUTBOUND_AVATAR_DATA_STATS_KEY = "outbound_av_data_kbps";
|
|
const QString INBOUND_AVATAR_DATA_STATS_KEY = "inbound_av_data_kbps";
|
|
|
|
struct SlaveSharedData;
|
|
|
|
class AvatarMixerClientData : public NodeData {
|
|
Q_OBJECT
|
|
public:
|
|
AvatarMixerClientData(const QUuid& nodeID, Node::LocalID nodeLocalID);
|
|
virtual ~AvatarMixerClientData() {}
|
|
using HRCTime = p_high_resolution_clock::time_point;
|
|
using PerNodeTraitVersions = std::unordered_map<Node::LocalID, AvatarTraits::TraitVersions>;
|
|
|
|
int parseData(ReceivedMessage& message) override;
|
|
AvatarData& getAvatar() { return *_avatar; }
|
|
const AvatarData& getAvatar() const { return *_avatar; }
|
|
const AvatarData* getConstAvatarData() const { return _avatar.get(); }
|
|
AvatarSharedPointer getAvatarSharedPointer() const { return _avatar; }
|
|
|
|
uint16_t getLastBroadcastSequenceNumber(NLPacket::LocalID nodeID) const;
|
|
void setLastBroadcastSequenceNumber(NLPacket::LocalID nodeID, uint16_t sequenceNumber)
|
|
{ _lastBroadcastSequenceNumbers[nodeID] = sequenceNumber; }
|
|
Q_INVOKABLE void removeLastBroadcastSequenceNumber(NLPacket::LocalID nodeID) { _lastBroadcastSequenceNumbers.erase(nodeID); }
|
|
bool isIgnoreRadiusEnabled() const { return _isIgnoreRadiusEnabled; }
|
|
void setIsIgnoreRadiusEnabled(bool enabled) { _isIgnoreRadiusEnabled = enabled; }
|
|
|
|
uint64_t getLastBroadcastTime(NLPacket::LocalID nodeUUID) const;
|
|
void setLastBroadcastTime(NLPacket::LocalID nodeUUID, uint64_t broadcastTime) { _lastBroadcastTimes[nodeUUID] = broadcastTime; }
|
|
Q_INVOKABLE void removeLastBroadcastTime(NLPacket::LocalID nodeUUID) { _lastBroadcastTimes.erase(nodeUUID); }
|
|
|
|
Q_INVOKABLE void cleanupKilledNode(const QUuid& nodeUUID, Node::LocalID nodeLocalID);
|
|
|
|
uint16_t getLastReceivedSequenceNumber() const { return _lastReceivedSequenceNumber; }
|
|
|
|
uint64_t getIdentityChangeTimestamp() const { return _identityChangeTimestamp; }
|
|
void flagIdentityChange() { _identityChangeTimestamp = usecTimestampNow(); }
|
|
bool getAvatarSessionDisplayNameMustChange() const { return _avatarSessionDisplayNameMustChange; }
|
|
void setAvatarSessionDisplayNameMustChange(bool set = true) { _avatarSessionDisplayNameMustChange = set; }
|
|
|
|
void resetNumAvatarsSentLastFrame() { _numAvatarsSentLastFrame = 0; }
|
|
void incrementNumAvatarsSentLastFrame() { ++_numAvatarsSentLastFrame; }
|
|
int getNumAvatarsSentLastFrame() const { return _numAvatarsSentLastFrame; }
|
|
|
|
void recordNumOtherAvatarStarves(int numAvatarsHeldBack) { _otherAvatarStarves.updateAverage((float) numAvatarsHeldBack); }
|
|
float getAvgNumOtherAvatarStarvesPerSecond() const { return _otherAvatarStarves.getAverageSampleValuePerSecond(); }
|
|
|
|
void recordNumOtherAvatarSkips(int numOtherAvatarSkips) { _otherAvatarSkips.updateAverage((float) numOtherAvatarSkips); }
|
|
float getAvgNumOtherAvatarSkipsPerSecond() const { return _otherAvatarSkips.getAverageSampleValuePerSecond(); }
|
|
|
|
void incrementNumOutOfOrderSends() { ++_numOutOfOrderSends; }
|
|
|
|
int getNumFramesSinceFRDAdjustment() const { return _numFramesSinceAdjustment; }
|
|
void incrementNumFramesSinceFRDAdjustment() { ++_numFramesSinceAdjustment; }
|
|
void resetNumFramesSinceFRDAdjustment() { _numFramesSinceAdjustment = 0; }
|
|
|
|
void recordSentAvatarData(int numBytes) { _avgOtherAvatarDataRate.updateAverage((float) numBytes); }
|
|
|
|
float getOutboundAvatarDataKbps() const
|
|
{ return _avgOtherAvatarDataRate.getAverageSampleValuePerSecond() / (float) BYTES_PER_KILOBIT; }
|
|
|
|
void loadJSONStats(QJsonObject& jsonObject) const;
|
|
|
|
glm::vec3 getPosition() const { return _avatar ? _avatar->getClientGlobalPosition() : glm::vec3(0); }
|
|
bool isRadiusIgnoring(const QUuid& other) const;
|
|
void addToRadiusIgnoringSet(const QUuid& other);
|
|
void removeFromRadiusIgnoringSet(const QUuid& other);
|
|
void ignoreOther(SharedNodePointer self, SharedNodePointer other);
|
|
void ignoreOther(const Node* self, const Node* other);
|
|
|
|
void readViewFrustumPacket(const QByteArray& message);
|
|
|
|
bool otherAvatarInView(const AABox& otherAvatarBox);
|
|
|
|
void resetInViewStats() { _recentOtherAvatarsInView = _recentOtherAvatarsOutOfView = 0; }
|
|
void incrementAvatarInView() { _recentOtherAvatarsInView++; }
|
|
void incrementAvatarOutOfView() { _recentOtherAvatarsOutOfView++; }
|
|
const QString& getBaseDisplayName() { return _baseDisplayName; }
|
|
void setBaseDisplayName(const QString& baseDisplayName) { _baseDisplayName = baseDisplayName; }
|
|
bool getRequestsDomainListData() { return _requestsDomainListData; }
|
|
void setRequestsDomainListData(bool requesting) { _requestsDomainListData = requesting; }
|
|
bool getPrevRequestsDomainListData() { return _prevRequestsDomainListData; }
|
|
void setPrevRequestsDomainListData(bool requesting) { _prevRequestsDomainListData = requesting; }
|
|
|
|
const ConicalViewFrustums& getViewFrustums() const { return _currentViewFrustums; }
|
|
|
|
uint64_t getLastOtherAvatarEncodeTime(NLPacket::LocalID otherAvatar) const;
|
|
void setLastOtherAvatarEncodeTime(NLPacket::LocalID otherAvatar, uint64_t time);
|
|
|
|
QVector<JointData>& getLastOtherAvatarSentJoints(NLPacket::LocalID otherAvatar) { return _lastOtherAvatarSentJoints[otherAvatar]; }
|
|
|
|
void queuePacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer node);
|
|
int processPackets(const SlaveSharedData& slaveSharedData); // returns number of packets processed
|
|
|
|
void processSetTraitsMessage(ReceivedMessage& message, const SlaveSharedData& slaveSharedData, Node& sendingNode);
|
|
void processBulkAvatarTraitsAckMessage(ReceivedMessage& message);
|
|
void checkSkeletonURLAgainstWhitelist(const SlaveSharedData& slaveSharedData, Node& sendingNode,
|
|
AvatarTraits::TraitVersion traitVersion);
|
|
|
|
using TraitsCheckTimestamp = std::chrono::steady_clock::time_point;
|
|
|
|
TraitsCheckTimestamp getLastReceivedTraitsChange() const { return _lastReceivedTraitsChange; }
|
|
|
|
AvatarTraits::TraitVersions& getLastReceivedTraitVersions() { return _lastReceivedTraitVersions; }
|
|
const AvatarTraits::TraitVersions& getLastReceivedTraitVersions() const { return _lastReceivedTraitVersions; }
|
|
|
|
TraitsCheckTimestamp getLastOtherAvatarTraitsSendPoint(Node::LocalID otherAvatar) const;
|
|
void setLastOtherAvatarTraitsSendPoint(Node::LocalID otherAvatar, TraitsCheckTimestamp sendPoint)
|
|
{ _lastSentTraitsTimestamps[otherAvatar] = sendPoint; }
|
|
|
|
AvatarTraits::TraitMessageSequence getTraitsMessageSequence() const { return _currentTraitsMessageSequence; }
|
|
AvatarTraits::TraitMessageSequence nextTraitsMessageSequence() { return ++_currentTraitsMessageSequence; }
|
|
AvatarTraits::TraitVersions& getPendingTraitVersions(AvatarTraits::TraitMessageSequence seq, Node::LocalID otherId) {
|
|
return _perNodePendingTraitVersions[seq][otherId];
|
|
}
|
|
|
|
AvatarTraits::TraitVersions& getLastSentTraitVersions(Node::LocalID otherAvatar) { return _perNodeSentTraitVersions[otherAvatar]; }
|
|
AvatarTraits::TraitVersions& getLastAckedTraitVersions(Node::LocalID otherAvatar) { return _perNodeAckedTraitVersions[otherAvatar]; }
|
|
|
|
void resetSentTraitData(Node::LocalID nodeID);
|
|
|
|
private:
|
|
struct PacketQueue : public std::queue<QSharedPointer<ReceivedMessage>> {
|
|
QWeakPointer<Node> node;
|
|
};
|
|
PacketQueue _packetQueue;
|
|
|
|
AvatarSharedPointer _avatar { new AvatarData() };
|
|
|
|
uint16_t _lastReceivedSequenceNumber { 0 };
|
|
std::unordered_map<NLPacket::LocalID, uint16_t> _lastBroadcastSequenceNumbers;
|
|
std::unordered_map<NLPacket::LocalID, uint64_t> _lastBroadcastTimes;
|
|
|
|
// this is a map of the last time we encoded an "other" avatar for
|
|
// sending to "this" node
|
|
std::unordered_map<NLPacket::LocalID, uint64_t> _lastOtherAvatarEncodeTime;
|
|
std::unordered_map<NLPacket::LocalID, QVector<JointData>> _lastOtherAvatarSentJoints;
|
|
|
|
uint64_t _identityChangeTimestamp;
|
|
bool _avatarSessionDisplayNameMustChange{ true };
|
|
bool _avatarSkeletonModelUrlMustChange{ false };
|
|
|
|
int _numAvatarsSentLastFrame = 0;
|
|
int _numFramesSinceAdjustment = 0;
|
|
|
|
SimpleMovingAverage _otherAvatarStarves;
|
|
SimpleMovingAverage _otherAvatarSkips;
|
|
int _numOutOfOrderSends = 0;
|
|
|
|
SimpleMovingAverage _avgOtherAvatarDataRate;
|
|
std::vector<QUuid> _radiusIgnoredOthers;
|
|
ConicalViewFrustums _currentViewFrustums;
|
|
|
|
int _recentOtherAvatarsInView { 0 };
|
|
int _recentOtherAvatarsOutOfView { 0 };
|
|
QString _baseDisplayName{}; // The santized key used in determinging unique sessionDisplayName, so that we can remove from dictionary.
|
|
bool _requestsDomainListData { false };
|
|
bool _prevRequestsDomainListData{ false };
|
|
|
|
AvatarTraits::TraitVersions _lastReceivedTraitVersions;
|
|
TraitsCheckTimestamp _lastReceivedTraitsChange;
|
|
|
|
AvatarTraits::TraitMessageSequence _currentTraitsMessageSequence{ 0 };
|
|
|
|
// Cache of trait versions sent in a given packet (indexed by sequence number)
|
|
// When an ack is received, the sequence number in the ack is used to look up
|
|
// the sent trait versions and they are copied to _perNodeAckedTraitVersions.
|
|
// We remember the data in _perNodePendingTraitVersions instead of requiring
|
|
// the client to return all of the versions for each trait it received in a given packet,
|
|
// reducing the size of the ack packet.
|
|
std::unordered_map<AvatarTraits::TraitMessageSequence, PerNodeTraitVersions> _perNodePendingTraitVersions;
|
|
|
|
// Versions of traits that have been acked, which will be compared to incoming
|
|
// trait updates. Incoming updates going to a given node will be ignored if
|
|
// the ack for the previous packet (containing those versions) has not been
|
|
// received.
|
|
PerNodeTraitVersions _perNodeAckedTraitVersions;
|
|
|
|
std::unordered_map<Node::LocalID, TraitsCheckTimestamp> _lastSentTraitsTimestamps;
|
|
|
|
// cache of traits sent to a node which are compared to incoming traits to
|
|
// prevent sending traits that have already been sent.
|
|
PerNodeTraitVersions _perNodeSentTraitVersions;
|
|
|
|
std::atomic_bool _isIgnoreRadiusEnabled { false };
|
|
};
|
|
|
|
#endif // hifi_AvatarMixerClientData_h
|