mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-07-22 18:43:20 +02:00
1762 lines
71 KiB
C++
1762 lines
71 KiB
C++
//
|
|
// Avatar.cpp
|
|
// interface/src/avatar
|
|
//
|
|
// Created by Philip Rosedale on 9/11/12.
|
|
// 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
|
|
//
|
|
|
|
#include "Avatar.h"
|
|
|
|
#include <QtCore/QThread>
|
|
#include <glm/gtx/transform.hpp>
|
|
#include <glm/gtx/vector_query.hpp>
|
|
|
|
#include <AvatarConstants.h>
|
|
#include <shared/QtHelpers.h>
|
|
#include <DeferredLightingEffect.h>
|
|
#include <EntityTreeRenderer.h>
|
|
#include <NodeList.h>
|
|
#include <NumericalConstants.h>
|
|
#include <OctreeUtils.h>
|
|
#include <udt/PacketHeaders.h>
|
|
#include <PerfStat.h>
|
|
#include <Rig.h>
|
|
#include <SharedUtil.h>
|
|
#include <TextRenderer3D.h>
|
|
#include <VariantMapToScriptValue.h>
|
|
#include <DebugDraw.h>
|
|
#include <shared/Camera.h>
|
|
#include <SoftAttachmentModel.h>
|
|
#include <render/TransitionStage.h>
|
|
#include "ModelEntityItem.h"
|
|
#include "RenderableModelEntityItem.h"
|
|
|
|
#include "Logging.h"
|
|
|
|
using namespace std;
|
|
|
|
const int NUM_BODY_CONE_SIDES = 9;
|
|
const float CHAT_MESSAGE_SCALE = 0.0015f;
|
|
const float CHAT_MESSAGE_HEIGHT = 0.1f;
|
|
const float DISPLAYNAME_FADE_TIME = 0.5f;
|
|
const float DISPLAYNAME_FADE_FACTOR = pow(0.01f, 1.0f / DISPLAYNAME_FADE_TIME);
|
|
const float DISPLAYNAME_ALPHA = 1.0f;
|
|
const float DISPLAYNAME_BACKGROUND_ALPHA = 0.4f;
|
|
const glm::vec3 HAND_TO_PALM_OFFSET(0.0f, 0.12f, 0.08f);
|
|
|
|
namespace render {
|
|
template <> const ItemKey payloadGetKey(const AvatarSharedPointer& avatar) {
|
|
return ItemKey::Builder::opaqueShape().withTypeMeta();
|
|
}
|
|
template <> const Item::Bound payloadGetBound(const AvatarSharedPointer& avatar) {
|
|
return static_pointer_cast<Avatar>(avatar)->getBounds();
|
|
}
|
|
template <> void payloadRender(const AvatarSharedPointer& avatar, RenderArgs* args) {
|
|
auto avatarPtr = static_pointer_cast<Avatar>(avatar);
|
|
if (avatarPtr->isInitialized() && args) {
|
|
PROFILE_RANGE_BATCH(*args->_batch, "renderAvatarPayload");
|
|
avatarPtr->render(args);
|
|
}
|
|
}
|
|
template <> uint32_t metaFetchMetaSubItems(const AvatarSharedPointer& avatar, ItemIDs& subItems) {
|
|
auto avatarPtr = static_pointer_cast<Avatar>(avatar);
|
|
if (avatarPtr->getSkeletonModel()) {
|
|
auto& metaSubItems = avatarPtr->getSkeletonModel()->fetchRenderItemIDs();
|
|
subItems.insert(subItems.end(), metaSubItems.begin(), metaSubItems.end());
|
|
return (uint32_t) metaSubItems.size();
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
bool showAvatars { true };
|
|
void Avatar::setShowAvatars(bool render) {
|
|
showAvatars = render;
|
|
}
|
|
|
|
static bool showReceiveStats = false;
|
|
void Avatar::setShowReceiveStats(bool receiveStats) {
|
|
showReceiveStats = receiveStats;
|
|
}
|
|
|
|
static bool showMyLookAtVectors = false;
|
|
void Avatar::setShowMyLookAtVectors(bool showMine) {
|
|
showMyLookAtVectors = showMine;
|
|
}
|
|
|
|
static bool showOtherLookAtVectors = false;
|
|
void Avatar::setShowOtherLookAtVectors(bool showOthers) {
|
|
showOtherLookAtVectors = showOthers;
|
|
}
|
|
|
|
static bool showCollisionShapes = false;
|
|
void Avatar::setShowCollisionShapes(bool render) {
|
|
showCollisionShapes = render;
|
|
}
|
|
|
|
static bool showNamesAboveHeads = false;
|
|
void Avatar::setShowNamesAboveHeads(bool show) {
|
|
showNamesAboveHeads = show;
|
|
}
|
|
|
|
Avatar::Avatar(QThread* thread) :
|
|
_voiceSphereID(GeometryCache::UNKNOWN_ID)
|
|
{
|
|
// we may have been created in the network thread, but we live in the main thread
|
|
moveToThread(thread);
|
|
|
|
setModelScale(1.0f); // avatar scale is uniform
|
|
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
_nameRectGeometryID = geometryCache->allocateID();
|
|
_leftPointerGeometryID = geometryCache->allocateID();
|
|
_rightPointerGeometryID = geometryCache->allocateID();
|
|
_lastRenderUpdateTime = usecTimestampNow();
|
|
}
|
|
|
|
Avatar::~Avatar() {
|
|
auto treeRenderer = DependencyManager::get<EntityTreeRenderer>();
|
|
EntityTreePointer entityTree = treeRenderer ? treeRenderer->getTree() : nullptr;
|
|
if (entityTree) {
|
|
entityTree->withWriteLock([&] {
|
|
AvatarEntityMap avatarEntities = getAvatarEntityData();
|
|
for (auto entityID : avatarEntities.keys()) {
|
|
entityTree->deleteEntity(entityID, true, true);
|
|
}
|
|
});
|
|
}
|
|
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
if (geometryCache) {
|
|
geometryCache->releaseID(_nameRectGeometryID);
|
|
geometryCache->releaseID(_leftPointerGeometryID);
|
|
geometryCache->releaseID(_rightPointerGeometryID);
|
|
}
|
|
}
|
|
|
|
void Avatar::init() {
|
|
getHead()->init();
|
|
_initialized = true;
|
|
}
|
|
|
|
glm::vec3 Avatar::getChestPosition() const {
|
|
// for now, let's just assume that the "chest" is halfway between the root and the neck
|
|
glm::vec3 neckPosition;
|
|
return _skeletonModel->getNeckPosition(neckPosition) ? (getWorldPosition() + neckPosition) * 0.5f : getWorldPosition();
|
|
}
|
|
|
|
glm::vec3 Avatar::getNeckPosition() const {
|
|
glm::vec3 neckPosition;
|
|
return _skeletonModel->getNeckPosition(neckPosition) ? neckPosition : getWorldPosition();
|
|
}
|
|
|
|
AABox Avatar::getBounds() const {
|
|
if (!_skeletonModel->isRenderable() || _skeletonModel->needsFixupInScene()) {
|
|
// approximately 2m tall, scaled to user request.
|
|
return AABox(getWorldPosition() - glm::vec3(getModelScale()), getModelScale() * 2.0f);
|
|
}
|
|
return _skeletonModel->getRenderableMeshBound();
|
|
}
|
|
|
|
void Avatar::animateScaleChanges(float deltaTime) {
|
|
|
|
if (_isAnimatingScale) {
|
|
float currentScale = getModelScale();
|
|
float desiredScale = getDomainLimitedScale();
|
|
|
|
// use exponential decay toward the domain limit clamped scale
|
|
const float SCALE_ANIMATION_TIMESCALE = 0.5f;
|
|
float blendFactor = glm::clamp(deltaTime / SCALE_ANIMATION_TIMESCALE, 0.0f, 1.0f);
|
|
float animatedScale = (1.0f - blendFactor) * currentScale + blendFactor * desiredScale;
|
|
|
|
// snap to the end when we get close enough
|
|
const float MIN_RELATIVE_ERROR = 0.001f;
|
|
float relativeError = fabsf(desiredScale - currentScale) / desiredScale;
|
|
if (relativeError < MIN_RELATIVE_ERROR) {
|
|
animatedScale = desiredScale;
|
|
_isAnimatingScale = false;
|
|
}
|
|
setModelScale(animatedScale); // avatar scale is uniform
|
|
|
|
// flag the joints as having changed for force update to RenderItem
|
|
_hasNewJointData = true;
|
|
|
|
// TODO: rebuilding the shape constantly is somehwat expensive.
|
|
// We should only rebuild after significant change.
|
|
rebuildCollisionShape();
|
|
}
|
|
}
|
|
|
|
void Avatar::setTargetScale(float targetScale) {
|
|
float newValue = glm::clamp(targetScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE);
|
|
if (_targetScale != newValue) {
|
|
_targetScale = newValue;
|
|
_scaleChanged = usecTimestampNow();
|
|
_isAnimatingScale = true;
|
|
}
|
|
}
|
|
|
|
void Avatar::setAvatarEntityDataChanged(bool value) {
|
|
AvatarData::setAvatarEntityDataChanged(value);
|
|
_avatarEntityDataHashes.clear();
|
|
}
|
|
|
|
void Avatar::updateAvatarEntities() {
|
|
PerformanceTimer perfTimer("attachments");
|
|
// - if queueEditEntityMessage sees clientOnly flag it does _myAvatar->updateAvatarEntity()
|
|
// - updateAvatarEntity saves the bytes and sets _avatarEntityDataLocallyEdited
|
|
// - MyAvatar::update notices _avatarEntityDataLocallyEdited and calls sendIdentityPacket
|
|
// - sendIdentityPacket sends the entity bytes to the server which relays them to other interfaces
|
|
// - AvatarHashMap::processAvatarIdentityPacket on other interfaces call avatar->setAvatarEntityData()
|
|
// - setAvatarEntityData saves the bytes and sets _avatarEntityDataChanged = true
|
|
// - (My)Avatar::simulate notices _avatarEntityDataChanged and here we are...
|
|
|
|
if (!_avatarEntityDataChanged) {
|
|
return;
|
|
}
|
|
|
|
if (getID() == QUuid()) {
|
|
return; // wait until MyAvatar gets an ID before doing this.
|
|
}
|
|
|
|
auto treeRenderer = DependencyManager::get<EntityTreeRenderer>();
|
|
EntityTreePointer entityTree = treeRenderer ? treeRenderer->getTree() : nullptr;
|
|
if (!entityTree) {
|
|
return;
|
|
}
|
|
|
|
QScriptEngine scriptEngine;
|
|
entityTree->withWriteLock([&] {
|
|
AvatarEntityMap avatarEntities = getAvatarEntityData();
|
|
AvatarEntityMap::const_iterator dataItr = avatarEntities.begin();
|
|
while (dataItr != avatarEntities.end()) {
|
|
// compute hash of data. TODO? cache this?
|
|
QByteArray data = dataItr.value();
|
|
uint32_t newHash = qHash(data);
|
|
|
|
// check to see if we recognize this hash and whether it was already successfully processed
|
|
QUuid entityID = dataItr.key();
|
|
MapOfAvatarEntityDataHashes::iterator stateItr = _avatarEntityDataHashes.find(entityID);
|
|
if (stateItr != _avatarEntityDataHashes.end()) {
|
|
if (stateItr.value().success) {
|
|
if (newHash == stateItr.value().hash) {
|
|
// data hasn't changed --> nothing to do
|
|
++dataItr;
|
|
continue;
|
|
}
|
|
} else {
|
|
// NOTE: if the data was unsuccessful in producing an entity in the past
|
|
// we will try again just in case something changed (unlikely).
|
|
// Unfortunately constantly trying to build the entity for this data costs
|
|
// CPU cycles that we'd rather not spend.
|
|
// TODO? put a maximum number of tries on this?
|
|
}
|
|
} else {
|
|
// remember this hash for the future
|
|
stateItr = _avatarEntityDataHashes.insert(entityID, AvatarEntityDataHash(newHash));
|
|
}
|
|
++dataItr;
|
|
|
|
// see EntityEditPacketSender::queueEditEntityMessage for the other end of this. unpack properties
|
|
// and either add or update the entity.
|
|
QJsonDocument jsonProperties = QJsonDocument::fromBinaryData(data);
|
|
if (!jsonProperties.isObject()) {
|
|
qCDebug(avatars_renderer) << "got bad avatarEntity json" << QString(data.toHex());
|
|
continue;
|
|
}
|
|
|
|
QVariant variantProperties = jsonProperties.toVariant();
|
|
QVariantMap asMap = variantProperties.toMap();
|
|
QScriptValue scriptProperties = variantMapToScriptValue(asMap, scriptEngine);
|
|
EntityItemProperties properties;
|
|
EntityItemPropertiesFromScriptValueHonorReadOnly(scriptProperties, properties);
|
|
properties.setClientOnly(true);
|
|
properties.setOwningAvatarID(getID());
|
|
|
|
// there's no entity-server to tell us we're the simulation owner, so always set the
|
|
// simulationOwner to the owningAvatarID and a high priority.
|
|
properties.setSimulationOwner(getID(), AVATAR_ENTITY_SIMULATION_PRIORITY);
|
|
|
|
if (properties.getParentID() == AVATAR_SELF_ID) {
|
|
properties.setParentID(getID());
|
|
}
|
|
|
|
// NOTE: if this avatar entity is not attached to us, strip its entity script completely...
|
|
auto attachedScript = properties.getScript();
|
|
if (!isMyAvatar() && !attachedScript.isEmpty()) {
|
|
qCDebug(avatars_renderer) << "removing entity script from avatar attached entity:" << entityID << "old script:" << attachedScript;
|
|
QString noScript;
|
|
properties.setScript(noScript);
|
|
}
|
|
|
|
auto specifiedHref = properties.getHref();
|
|
if (!isMyAvatar() && !specifiedHref.isEmpty()) {
|
|
qCDebug(avatars_renderer) << "removing entity href from avatar attached entity:" << entityID << "old href:" << specifiedHref;
|
|
QString noHref;
|
|
properties.setHref(noHref);
|
|
}
|
|
|
|
// When grabbing avatar entities, they are parented to the joint moving them, then when un-grabbed
|
|
// they go back to the default parent (null uuid). When un-gripped, others saw the entity disappear.
|
|
// The thinking here is the local position was noticed as changing, but not the parentID (since it is now
|
|
// back to the default), and the entity flew off somewhere. Marking all changed definitely fixes this,
|
|
// and seems safe (per Seth).
|
|
properties.markAllChanged();
|
|
|
|
// try to build the entity
|
|
EntityItemPointer entity = entityTree->findEntityByEntityItemID(EntityItemID(entityID));
|
|
bool success = true;
|
|
if (entity) {
|
|
if (entityTree->updateEntity(entityID, properties)) {
|
|
entity->updateLastEditedFromRemote();
|
|
} else {
|
|
success = false;
|
|
}
|
|
} else {
|
|
entity = entityTree->addEntity(entityID, properties);
|
|
if (!entity) {
|
|
success = false;
|
|
}
|
|
}
|
|
stateItr.value().success = success;
|
|
}
|
|
|
|
AvatarEntityIDs recentlyDettachedAvatarEntities = getAndClearRecentlyDetachedIDs();
|
|
if (!recentlyDettachedAvatarEntities.empty()) {
|
|
// only lock this thread when absolutely necessary
|
|
AvatarEntityMap avatarEntityData;
|
|
_avatarEntitiesLock.withReadLock([&] {
|
|
avatarEntityData = _avatarEntityData;
|
|
});
|
|
foreach (auto entityID, recentlyDettachedAvatarEntities) {
|
|
if (!avatarEntityData.contains(entityID)) {
|
|
entityTree->deleteEntity(entityID, true, true);
|
|
}
|
|
}
|
|
|
|
// remove stale data hashes
|
|
foreach (auto entityID, recentlyDettachedAvatarEntities) {
|
|
MapOfAvatarEntityDataHashes::iterator stateItr = _avatarEntityDataHashes.find(entityID);
|
|
if (stateItr != _avatarEntityDataHashes.end()) {
|
|
_avatarEntityDataHashes.erase(stateItr);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
setAvatarEntityDataChanged(false);
|
|
}
|
|
|
|
void Avatar::relayJointDataToChildren() {
|
|
forEachChild([&](SpatiallyNestablePointer child) {
|
|
if (child->getNestableType() == NestableType::Entity) {
|
|
auto modelEntity = std::dynamic_pointer_cast<RenderableModelEntityItem>(child);
|
|
if (modelEntity) {
|
|
if (modelEntity->getRelayParentJoints()) {
|
|
if (!modelEntity->getJointMapCompleted() || _reconstructSoftEntitiesJointMap) {
|
|
QStringList modelJointNames = modelEntity->getJointNames();
|
|
int numJoints = modelJointNames.count();
|
|
std::vector<int> map;
|
|
map.reserve(numJoints);
|
|
for (int jointIndex = 0; jointIndex < numJoints; jointIndex++) {
|
|
QString jointName = modelJointNames.at(jointIndex);
|
|
int avatarJointIndex = getJointIndex(jointName);
|
|
glm::quat jointRotation;
|
|
glm::vec3 jointTranslation;
|
|
if (avatarJointIndex < 0) {
|
|
jointRotation = modelEntity->getAbsoluteJointRotationInObjectFrame(jointIndex);
|
|
jointTranslation = modelEntity->getAbsoluteJointTranslationInObjectFrame(jointIndex);
|
|
map.push_back(-1);
|
|
} else {
|
|
int jointIndex = getJointIndex(jointName);
|
|
jointRotation = getJointRotation(jointIndex);
|
|
jointTranslation = getJointTranslation(jointIndex);
|
|
map.push_back(avatarJointIndex);
|
|
}
|
|
modelEntity->setLocalJointRotation(jointIndex, jointRotation);
|
|
modelEntity->setLocalJointTranslation(jointIndex, jointTranslation);
|
|
}
|
|
modelEntity->setJointMap(map);
|
|
} else {
|
|
QStringList modelJointNames = modelEntity->getJointNames();
|
|
int numJoints = modelJointNames.count();
|
|
for (int jointIndex = 0; jointIndex < numJoints; jointIndex++) {
|
|
int avatarJointIndex = modelEntity->avatarJointIndex(jointIndex);
|
|
glm::quat jointRotation;
|
|
glm::vec3 jointTranslation;
|
|
if (avatarJointIndex >=0) {
|
|
jointRotation = getJointRotation(avatarJointIndex);
|
|
jointTranslation = getJointTranslation(avatarJointIndex);
|
|
} else {
|
|
jointRotation = modelEntity->getAbsoluteJointRotationInObjectFrame(jointIndex);
|
|
jointTranslation = modelEntity->getAbsoluteJointTranslationInObjectFrame(jointIndex);
|
|
}
|
|
modelEntity->setLocalJointRotation(jointIndex, jointRotation);
|
|
modelEntity->setLocalJointTranslation(jointIndex, jointTranslation);
|
|
}
|
|
}
|
|
Transform avatarTransform = _skeletonModel->getTransform();
|
|
avatarTransform.setScale(_skeletonModel->getScale());
|
|
modelEntity->setOverrideTransform(avatarTransform, _skeletonModel->getOffset());
|
|
modelEntity->simulateRelayedJoints();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
_reconstructSoftEntitiesJointMap = false;
|
|
}
|
|
|
|
void Avatar::simulate(float deltaTime, bool inView) {
|
|
PROFILE_RANGE(simulation, "simulate");
|
|
|
|
_simulationRate.increment();
|
|
if (inView) {
|
|
_simulationInViewRate.increment();
|
|
}
|
|
|
|
PerformanceTimer perfTimer("simulate");
|
|
{
|
|
PROFILE_RANGE(simulation, "updateJoints");
|
|
if (inView) {
|
|
Head* head = getHead();
|
|
if (_hasNewJointData) {
|
|
_skeletonModel->getRig().copyJointsFromJointData(_jointData);
|
|
glm::mat4 rootTransform = glm::scale(_skeletonModel->getScale()) * glm::translate(_skeletonModel->getOffset());
|
|
_skeletonModel->getRig().computeExternalPoses(rootTransform);
|
|
_jointDataSimulationRate.increment();
|
|
|
|
_skeletonModel->simulate(deltaTime, true);
|
|
|
|
locationChanged(); // joints changed, so if there are any children, update them.
|
|
_hasNewJointData = false;
|
|
|
|
glm::vec3 headPosition = getWorldPosition();
|
|
if (!_skeletonModel->getHeadPosition(headPosition)) {
|
|
headPosition = getWorldPosition();
|
|
}
|
|
head->setPosition(headPosition);
|
|
}
|
|
head->setScale(getModelScale());
|
|
head->simulate(deltaTime);
|
|
relayJointDataToChildren();
|
|
} else {
|
|
// a non-full update is still required so that the position, rotation, scale and bounds of the skeletonModel are updated.
|
|
_skeletonModel->simulate(deltaTime, false);
|
|
}
|
|
_skeletonModelSimulationRate.increment();
|
|
}
|
|
|
|
// update animation for display name fade in/out
|
|
if ( _displayNameTargetAlpha != _displayNameAlpha) {
|
|
// the alpha function is
|
|
// Fade out => alpha(t) = factor ^ t => alpha(t+dt) = alpha(t) * factor^(dt)
|
|
// Fade in => alpha(t) = 1 - factor^t => alpha(t+dt) = 1-(1-alpha(t))*coef^(dt)
|
|
// factor^(dt) = coef
|
|
float coef = pow(DISPLAYNAME_FADE_FACTOR, deltaTime);
|
|
if (_displayNameTargetAlpha < _displayNameAlpha) {
|
|
// Fading out
|
|
_displayNameAlpha *= coef;
|
|
} else {
|
|
// Fading in
|
|
_displayNameAlpha = 1 - (1 - _displayNameAlpha) * coef;
|
|
}
|
|
_displayNameAlpha = abs(_displayNameAlpha - _displayNameTargetAlpha) < 0.01f ? _displayNameTargetAlpha : _displayNameAlpha;
|
|
}
|
|
|
|
{
|
|
PROFILE_RANGE(simulation, "misc");
|
|
measureMotionDerivatives(deltaTime);
|
|
simulateAttachments(deltaTime);
|
|
updatePalms();
|
|
}
|
|
{
|
|
PROFILE_RANGE(simulation, "entities");
|
|
updateAvatarEntities();
|
|
}
|
|
}
|
|
|
|
float Avatar::getSimulationRate(const QString& rateName) const {
|
|
if (rateName == "") {
|
|
return _simulationRate.rate();
|
|
} else if (rateName == "avatar") {
|
|
return _simulationRate.rate();
|
|
} else if (rateName == "avatarInView") {
|
|
return _simulationInViewRate.rate();
|
|
} else if (rateName == "skeletonModel") {
|
|
return _skeletonModelSimulationRate.rate();
|
|
} else if (rateName == "jointData") {
|
|
return _jointDataSimulationRate.rate();
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
bool Avatar::isLookingAtMe(AvatarSharedPointer avatar) const {
|
|
const float HEAD_SPHERE_RADIUS = 0.1f;
|
|
glm::vec3 theirLookAt = dynamic_pointer_cast<Avatar>(avatar)->getHead()->getLookAtPosition();
|
|
glm::vec3 myEyePosition = getHead()->getEyePosition();
|
|
|
|
return glm::distance(theirLookAt, myEyePosition) <= (HEAD_SPHERE_RADIUS * getModelScale());
|
|
}
|
|
|
|
void Avatar::slamPosition(const glm::vec3& newPosition) {
|
|
setWorldPosition(newPosition);
|
|
_positionDeltaAccumulator = glm::vec3(0.0f);
|
|
setWorldVelocity(glm::vec3(0.0f));
|
|
_lastVelocity = glm::vec3(0.0f);
|
|
}
|
|
|
|
void Avatar::updateAttitude(const glm::quat& orientation) {
|
|
_skeletonModel->updateAttitude(orientation);
|
|
_worldUpDirection = orientation * Vectors::UNIT_Y;
|
|
}
|
|
|
|
void Avatar::applyPositionDelta(const glm::vec3& delta) {
|
|
setWorldPosition(getWorldPosition() + delta);
|
|
_positionDeltaAccumulator += delta;
|
|
}
|
|
|
|
void Avatar::measureMotionDerivatives(float deltaTime) {
|
|
PerformanceTimer perfTimer("derivatives");
|
|
// linear
|
|
const float MIN_DELTA_TIME = 0.001f;
|
|
const float safeDeltaTime = glm::max(deltaTime, MIN_DELTA_TIME);
|
|
float invDeltaTime = 1.0f / safeDeltaTime;
|
|
// Floating point error prevents us from computing velocity in a naive way
|
|
// (e.g. vel = (pos - oldPos) / dt) so instead we use _positionOffsetAccumulator.
|
|
glm::vec3 velocity = _positionDeltaAccumulator * invDeltaTime;
|
|
_positionDeltaAccumulator = glm::vec3(0.0f);
|
|
_acceleration = (velocity - _lastVelocity) * invDeltaTime;
|
|
_lastVelocity = velocity;
|
|
setWorldVelocity(velocity);
|
|
|
|
// angular
|
|
glm::quat orientation = getWorldOrientation();
|
|
glm::quat delta = glm::inverse(_lastOrientation) * orientation;
|
|
glm::vec3 angularVelocity = glm::axis(delta) * glm::angle(delta) * invDeltaTime;
|
|
setWorldAngularVelocity(angularVelocity);
|
|
_lastOrientation = getWorldOrientation();
|
|
}
|
|
|
|
enum TextRendererType {
|
|
CHAT,
|
|
DISPLAYNAME
|
|
};
|
|
|
|
static TextRenderer3D* textRenderer(TextRendererType type) {
|
|
static TextRenderer3D* chatRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY, -1,
|
|
false, SHADOW_EFFECT);
|
|
static TextRenderer3D* displayNameRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY);
|
|
|
|
switch(type) {
|
|
case CHAT:
|
|
return chatRenderer;
|
|
case DISPLAYNAME:
|
|
return displayNameRenderer;
|
|
}
|
|
|
|
return displayNameRenderer;
|
|
}
|
|
|
|
void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
|
|
auto avatarPayload = new render::Payload<AvatarData>(self);
|
|
auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);
|
|
|
|
if (_renderItemID == render::Item::INVALID_ITEM_ID) {
|
|
_renderItemID = scene->allocateID();
|
|
}
|
|
transaction.resetItem(_renderItemID, avatarPayloadPointer);
|
|
_skeletonModel->addToScene(scene, transaction);
|
|
for (auto& attachmentModel : _attachmentModels) {
|
|
attachmentModel->addToScene(scene, transaction);
|
|
}
|
|
|
|
_mustFadeIn = true;
|
|
}
|
|
|
|
void Avatar::fadeIn(render::ScenePointer scene) {
|
|
render::Transaction transaction;
|
|
fade(transaction, render::Transition::USER_ENTER_DOMAIN);
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
|
|
void Avatar::fadeOut(render::ScenePointer scene, KillAvatarReason reason) {
|
|
render::Transition::Type transitionType = render::Transition::USER_LEAVE_DOMAIN;
|
|
render::Transaction transaction;
|
|
|
|
if (reason == KillAvatarReason::YourAvatarEnteredTheirBubble) {
|
|
transitionType = render::Transition::BUBBLE_ISECT_TRESPASSER;
|
|
}
|
|
else if (reason == KillAvatarReason::TheirAvatarEnteredYourBubble) {
|
|
transitionType = render::Transition::BUBBLE_ISECT_OWNER;
|
|
}
|
|
fade(transaction, transitionType);
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
|
|
void Avatar::fade(render::Transaction& transaction, render::Transition::Type type) {
|
|
transaction.addTransitionToItem(_renderItemID, type);
|
|
for (auto& attachmentModel : _attachmentModels) {
|
|
for (auto itemId : attachmentModel->fetchRenderItemIDs()) {
|
|
transaction.addTransitionToItem(itemId, type, _renderItemID);
|
|
}
|
|
}
|
|
_isFading = true;
|
|
}
|
|
|
|
void Avatar::updateFadingStatus(render::ScenePointer scene) {
|
|
render::Transaction transaction;
|
|
transaction.queryTransitionOnItem(_renderItemID, [this](render::ItemID id, const render::Transition* transition) {
|
|
if (transition == nullptr || transition->isFinished) {
|
|
_isFading = false;
|
|
}
|
|
});
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
|
|
void Avatar::removeFromScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
|
|
transaction.removeItem(_renderItemID);
|
|
render::Item::clearID(_renderItemID);
|
|
_skeletonModel->removeFromScene(scene, transaction);
|
|
for (auto& attachmentModel : _attachmentModels) {
|
|
attachmentModel->removeFromScene(scene, transaction);
|
|
}
|
|
}
|
|
|
|
void Avatar::updateRenderItem(render::Transaction& transaction) {
|
|
if (render::Item::isValidID(_renderItemID)) {
|
|
transaction.updateItem<render::Payload<AvatarData>>(_renderItemID, [](render::Payload<AvatarData>& p) {});
|
|
}
|
|
}
|
|
|
|
void Avatar::postUpdate(float deltaTime, const render::ScenePointer& scene) {
|
|
|
|
if (isMyAvatar() ? showMyLookAtVectors : showOtherLookAtVectors) {
|
|
const float EYE_RAY_LENGTH = 10.0;
|
|
const glm::vec4 BLUE(0.0f, 0.0f, _lookAtSnappingEnabled ? 1.0f : 0.25f, 1.0f);
|
|
const glm::vec4 RED(_lookAtSnappingEnabled ? 1.0f : 0.25f, 0.0f, 0.0f, 1.0f);
|
|
|
|
int leftEyeJoint = getJointIndex("LeftEye");
|
|
glm::vec3 leftEyePosition;
|
|
glm::quat leftEyeRotation;
|
|
|
|
if (_skeletonModel->getJointPositionInWorldFrame(leftEyeJoint, leftEyePosition) &&
|
|
_skeletonModel->getJointRotationInWorldFrame(leftEyeJoint, leftEyeRotation)) {
|
|
DebugDraw::getInstance().drawRay(leftEyePosition, leftEyePosition + leftEyeRotation * Vectors::UNIT_Z * EYE_RAY_LENGTH, BLUE);
|
|
}
|
|
|
|
int rightEyeJoint = getJointIndex("RightEye");
|
|
glm::vec3 rightEyePosition;
|
|
glm::quat rightEyeRotation;
|
|
if (_skeletonModel->getJointPositionInWorldFrame(rightEyeJoint, rightEyePosition) &&
|
|
_skeletonModel->getJointRotationInWorldFrame(rightEyeJoint, rightEyeRotation)) {
|
|
DebugDraw::getInstance().drawRay(rightEyePosition, rightEyePosition + rightEyeRotation * Vectors::UNIT_Z * EYE_RAY_LENGTH, RED);
|
|
}
|
|
}
|
|
|
|
fixupModelsInScene(scene);
|
|
}
|
|
|
|
void Avatar::render(RenderArgs* renderArgs) {
|
|
auto& batch = *(renderArgs->_batch);
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__);
|
|
|
|
glm::vec3 viewPos = renderArgs->getViewFrustum().getPosition();
|
|
const float MAX_DISTANCE_SQUARED_FOR_SHOWING_POINTING_LASERS = 100.0f; // 10^2
|
|
if (glm::distance2(viewPos, getWorldPosition()) < MAX_DISTANCE_SQUARED_FOR_SHOWING_POINTING_LASERS) {
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
|
|
// render pointing lasers
|
|
glm::vec3 laserColor = glm::vec3(1.0f, 0.0f, 1.0f);
|
|
float laserLength = 50.0f;
|
|
glm::vec3 position;
|
|
glm::quat rotation;
|
|
bool havePosition, haveRotation;
|
|
|
|
if (_handState & LEFT_HAND_POINTING_FLAG) {
|
|
if (_handState & IS_FINGER_POINTING_FLAG) {
|
|
int leftIndexTip = getJointIndex("LeftHandIndex4");
|
|
int leftIndexTipJoint = getJointIndex("LeftHandIndex3");
|
|
havePosition = _skeletonModel->getJointPositionInWorldFrame(leftIndexTip, position);
|
|
haveRotation = _skeletonModel->getJointRotationInWorldFrame(leftIndexTipJoint, rotation);
|
|
} else {
|
|
int leftHand = _skeletonModel->getLeftHandJointIndex();
|
|
havePosition = _skeletonModel->getJointPositionInWorldFrame(leftHand, position);
|
|
haveRotation = _skeletonModel->getJointRotationInWorldFrame(leftHand, rotation);
|
|
}
|
|
|
|
if (havePosition && haveRotation) {
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__":leftHandPointer");
|
|
Transform pointerTransform;
|
|
pointerTransform.setTranslation(position);
|
|
pointerTransform.setRotation(rotation);
|
|
batch.setModelTransform(pointerTransform);
|
|
geometryCache->bindSimpleProgram(batch);
|
|
geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, laserLength, 0.0f), laserColor, _leftPointerGeometryID);
|
|
}
|
|
}
|
|
|
|
if (_handState & RIGHT_HAND_POINTING_FLAG) {
|
|
|
|
if (_handState & IS_FINGER_POINTING_FLAG) {
|
|
int rightIndexTip = getJointIndex("RightHandIndex4");
|
|
int rightIndexTipJoint = getJointIndex("RightHandIndex3");
|
|
havePosition = _skeletonModel->getJointPositionInWorldFrame(rightIndexTip, position);
|
|
haveRotation = _skeletonModel->getJointRotationInWorldFrame(rightIndexTipJoint, rotation);
|
|
} else {
|
|
int rightHand = _skeletonModel->getRightHandJointIndex();
|
|
havePosition = _skeletonModel->getJointPositionInWorldFrame(rightHand, position);
|
|
haveRotation = _skeletonModel->getJointRotationInWorldFrame(rightHand, rotation);
|
|
}
|
|
|
|
if (havePosition && haveRotation) {
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__":rightHandPointer");
|
|
Transform pointerTransform;
|
|
pointerTransform.setTranslation(position);
|
|
pointerTransform.setRotation(rotation);
|
|
batch.setModelTransform(pointerTransform);
|
|
geometryCache->bindSimpleProgram(batch);
|
|
geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, laserLength, 0.0f), laserColor, _rightPointerGeometryID);
|
|
}
|
|
}
|
|
}
|
|
|
|
ViewFrustum frustum = renderArgs->getViewFrustum();
|
|
if (!frustum.sphereIntersectsFrustum(getWorldPosition(), getBoundingRadius())) {
|
|
return;
|
|
}
|
|
|
|
if (showCollisionShapes && shouldRenderHead(renderArgs) && _skeletonModel->isRenderable()) {
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__":skeletonBoundingCollisionShapes");
|
|
const float BOUNDING_SHAPE_ALPHA = 0.7f;
|
|
_skeletonModel->renderBoundingCollisionShapes(renderArgs, *renderArgs->_batch, getModelScale(), BOUNDING_SHAPE_ALPHA);
|
|
}
|
|
|
|
if (showReceiveStats || showNamesAboveHeads) {
|
|
glm::vec3 toTarget = frustum.getPosition() - getWorldPosition();
|
|
float distanceToTarget = glm::length(toTarget);
|
|
const float DISPLAYNAME_DISTANCE = 20.0f;
|
|
updateDisplayNameAlpha(distanceToTarget < DISPLAYNAME_DISTANCE);
|
|
if (!isMyAvatar() || renderArgs->_cameraMode != (int8_t)CAMERA_MODE_FIRST_PERSON) {
|
|
auto& frustum = renderArgs->getViewFrustum();
|
|
auto textPosition = getDisplayNamePosition();
|
|
if (frustum.pointIntersectsFrustum(textPosition)) {
|
|
renderDisplayName(batch, frustum, textPosition);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
|
|
bool canTryFade{ false };
|
|
|
|
_attachmentsToDelete.clear();
|
|
|
|
// check to see if when we added our models to the scene they were ready, if they were not ready, then
|
|
// fix them up in the scene
|
|
render::Transaction transaction;
|
|
if (_skeletonModel->isRenderable() && _skeletonModel->needsFixupInScene()) {
|
|
_skeletonModel->removeFromScene(scene, transaction);
|
|
_skeletonModel->addToScene(scene, transaction);
|
|
canTryFade = true;
|
|
_isAnimatingScale = true;
|
|
}
|
|
for (auto attachmentModel : _attachmentModels) {
|
|
if (attachmentModel->isRenderable() && attachmentModel->needsFixupInScene()) {
|
|
attachmentModel->removeFromScene(scene, transaction);
|
|
attachmentModel->addToScene(scene, transaction);
|
|
}
|
|
}
|
|
|
|
if (_mustFadeIn && canTryFade) {
|
|
// Do it now to be sure all the sub items are ready and the fade is sent to them too
|
|
fade(transaction, render::Transition::USER_ENTER_DOMAIN);
|
|
_mustFadeIn = false;
|
|
}
|
|
|
|
for (auto attachmentModelToRemove : _attachmentsToRemove) {
|
|
attachmentModelToRemove->removeFromScene(scene, transaction);
|
|
}
|
|
_attachmentsToDelete.insert(_attachmentsToDelete.end(), _attachmentsToRemove.begin(), _attachmentsToRemove.end());
|
|
_attachmentsToRemove.clear();
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
|
|
bool Avatar::shouldRenderHead(const RenderArgs* renderArgs) const {
|
|
return true;
|
|
}
|
|
|
|
// virtual
|
|
void Avatar::simulateAttachments(float deltaTime) {
|
|
assert(_attachmentModels.size() == _attachmentModelsTexturesLoaded.size());
|
|
PerformanceTimer perfTimer("attachments");
|
|
for (int i = 0; i < (int)_attachmentModels.size(); i++) {
|
|
const AttachmentData& attachment = _attachmentData.at(i);
|
|
auto& model = _attachmentModels.at(i);
|
|
bool texturesLoaded = _attachmentModelsTexturesLoaded.at(i);
|
|
|
|
// Watch for texture loading
|
|
if (!texturesLoaded && model->getGeometry() && model->getGeometry()->areTexturesLoaded()) {
|
|
_attachmentModelsTexturesLoaded[i] = true;
|
|
model->updateRenderItems();
|
|
}
|
|
|
|
int jointIndex = getJointIndex(attachment.jointName);
|
|
glm::vec3 jointPosition;
|
|
glm::quat jointRotation;
|
|
if (attachment.isSoft) {
|
|
// soft attachments do not have transform offsets
|
|
model->setTransformNoUpdateRenderItems(Transform(getWorldOrientation() * Quaternions::Y_180, glm::vec3(1.0), getWorldPosition()));
|
|
model->simulate(deltaTime);
|
|
model->updateRenderItems();
|
|
} else {
|
|
if (_skeletonModel->getJointPositionInWorldFrame(jointIndex, jointPosition) &&
|
|
_skeletonModel->getJointRotationInWorldFrame(jointIndex, jointRotation)) {
|
|
model->setTransformNoUpdateRenderItems(Transform(jointRotation * attachment.rotation, glm::vec3(1.0), jointPosition + jointRotation * attachment.translation * getModelScale()));
|
|
float scale = getModelScale() * attachment.scale;
|
|
model->setScaleToFit(true, model->getNaturalDimensions() * scale, true); // hack to force rescale
|
|
model->setSnapModelToCenter(false); // hack to force resnap
|
|
model->setSnapModelToCenter(true);
|
|
model->simulate(deltaTime);
|
|
model->updateRenderItems();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
float Avatar::getBoundingRadius() const {
|
|
return getBounds().getLargestDimension() / 2.0f;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void debugValue(const QString& str, const glm::vec3& value) {
|
|
if (glm::any(glm::isnan(value)) || glm::any(glm::isinf(value))) {
|
|
qCWarning(avatars_renderer) << "debugValue() " << str << value;
|
|
}
|
|
};
|
|
void debugValue(const QString& str, const float& value) {
|
|
if (glm::isnan(value) || glm::isinf(value)) {
|
|
qCWarning(avatars_renderer) << "debugValue() " << str << value;
|
|
}
|
|
};
|
|
#define DEBUG_VALUE(str, value) debugValue(str, value)
|
|
#else
|
|
#define DEBUG_VALUE(str, value)
|
|
#endif
|
|
|
|
glm::vec3 Avatar::getDisplayNamePosition() const {
|
|
glm::vec3 namePosition(0.0f);
|
|
glm::vec3 bodyUpDirection = getBodyUpDirection();
|
|
DEBUG_VALUE("bodyUpDirection =", bodyUpDirection);
|
|
|
|
if (_skeletonModel->getNeckPosition(namePosition)) {
|
|
float headHeight = getHeadHeight();
|
|
DEBUG_VALUE("namePosition =", namePosition);
|
|
DEBUG_VALUE("headHeight =", headHeight);
|
|
|
|
static const float SLIGHTLY_ABOVE = 1.1f;
|
|
namePosition += bodyUpDirection * headHeight * SLIGHTLY_ABOVE;
|
|
} else {
|
|
const float HEAD_PROPORTION = 0.75f;
|
|
float size = getBoundingRadius();
|
|
|
|
DEBUG_VALUE("_position =", getWorldPosition());
|
|
DEBUG_VALUE("size =", size);
|
|
namePosition = getWorldPosition() + bodyUpDirection * (size * HEAD_PROPORTION);
|
|
}
|
|
|
|
if (glm::any(glm::isnan(namePosition)) || glm::any(glm::isinf(namePosition))) {
|
|
qCWarning(avatars_renderer) << "Invalid display name position" << namePosition
|
|
<< ", setting is to (0.0f, 0.5f, 0.0f)";
|
|
namePosition = glm::vec3(0.0f, 0.5f, 0.0f);
|
|
}
|
|
|
|
return namePosition;
|
|
}
|
|
|
|
Transform Avatar::calculateDisplayNameTransform(const ViewFrustum& view, const glm::vec3& textPosition) const {
|
|
Q_ASSERT_X(view.pointIntersectsFrustum(textPosition),
|
|
"Avatar::calculateDisplayNameTransform", "Text not in viewfrustum.");
|
|
glm::vec3 toFrustum = view.getPosition() - textPosition;
|
|
|
|
// Compute orientation
|
|
// If x and z are 0, atan(x, z) adais undefined, so default to 0 degrees
|
|
const float yawRotation = (toFrustum.x == 0.0f && toFrustum.z == 0.0f) ? 0.0f : glm::atan(toFrustum.x, toFrustum.z);
|
|
glm::quat orientation = glm::quat(glm::vec3(0.0f, yawRotation, 0.0f));
|
|
|
|
// Compute correct scale to apply
|
|
static const float DESIRED_HEIGHT_RAD = glm::radians(1.5f);
|
|
float scale = glm::length(toFrustum) * glm::tan(DESIRED_HEIGHT_RAD);
|
|
|
|
// Set transform
|
|
Transform result;
|
|
result.setTranslation(textPosition);
|
|
result.setRotation(orientation); // Always face the screen
|
|
result.setScale(scale);
|
|
// raise by half the scale up so that textPosition be the bottom
|
|
result.postTranslate(Vectors::UP / 2.0f);
|
|
|
|
return result;
|
|
}
|
|
|
|
void Avatar::renderDisplayName(gpu::Batch& batch, const ViewFrustum& view, const glm::vec3& textPosition) const {
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__);
|
|
|
|
bool shouldShowReceiveStats = showReceiveStats && !isMyAvatar();
|
|
|
|
// If we have nothing to draw, or it's totally transparent, or it's too close or behind the camera, return
|
|
static const float CLIP_DISTANCE = 0.2f;
|
|
if ((_displayName.isEmpty() && !shouldShowReceiveStats) || _displayNameAlpha == 0.0f
|
|
|| (glm::dot(view.getDirection(), getDisplayNamePosition() - view.getPosition()) <= CLIP_DISTANCE)) {
|
|
return;
|
|
}
|
|
auto renderer = textRenderer(DISPLAYNAME);
|
|
|
|
// optionally render timing stats for this avatar with the display name
|
|
QString renderedDisplayName = _displayName;
|
|
if (shouldShowReceiveStats) {
|
|
float kilobitsPerSecond = getAverageBytesReceivedPerSecond() / (float) BYTES_PER_KILOBIT;
|
|
|
|
QString statsFormat = QString("(%1 Kbps, %2 Hz)");
|
|
if (!renderedDisplayName.isEmpty()) {
|
|
statsFormat.prepend(" - ");
|
|
}
|
|
renderedDisplayName += statsFormat.arg(QString::number(kilobitsPerSecond, 'f', 2)).arg(getReceiveRate());
|
|
}
|
|
|
|
// Compute display name extent/position offset
|
|
const glm::vec2 extent = renderer->computeExtent(renderedDisplayName);
|
|
if (!glm::any(glm::isCompNull(extent, EPSILON))) {
|
|
const QRect nameDynamicRect = QRect(0, 0, (int)extent.x, (int)extent.y);
|
|
const int text_x = -nameDynamicRect.width() / 2;
|
|
const int text_y = -nameDynamicRect.height() / 2;
|
|
|
|
// Compute background position/size
|
|
static const float SLIGHTLY_IN_FRONT = 0.1f;
|
|
static const float BORDER_RELATIVE_SIZE = 0.1f;
|
|
static const float BEVEL_FACTOR = 0.1f;
|
|
const int border = BORDER_RELATIVE_SIZE * nameDynamicRect.height();
|
|
const int left = text_x - border;
|
|
const int bottom = text_y - border;
|
|
const int width = nameDynamicRect.width() + 2.0f * border;
|
|
const int height = nameDynamicRect.height() + 2.0f * border;
|
|
const int bevelDistance = BEVEL_FACTOR * height;
|
|
|
|
// Display name and background colors
|
|
glm::vec4 textColor(0.93f, 0.93f, 0.93f, _displayNameAlpha);
|
|
glm::vec4 backgroundColor(0.2f, 0.2f, 0.2f,
|
|
(_displayNameAlpha / DISPLAYNAME_ALPHA) * DISPLAYNAME_BACKGROUND_ALPHA);
|
|
|
|
// Compute display name transform
|
|
auto textTransform = calculateDisplayNameTransform(view, textPosition);
|
|
// Test on extent above insures abs(height) > 0.0f
|
|
textTransform.postScale(1.0f / height);
|
|
batch.setModelTransform(textTransform);
|
|
|
|
{
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__":renderBevelCornersRect");
|
|
DependencyManager::get<GeometryCache>()->bindSimpleProgram(batch, false, false, true, true, true);
|
|
DependencyManager::get<GeometryCache>()->renderBevelCornersRect(batch, left, bottom, width, height,
|
|
bevelDistance, backgroundColor, _nameRectGeometryID);
|
|
}
|
|
|
|
// Render actual name
|
|
QByteArray nameUTF8 = renderedDisplayName.toLocal8Bit();
|
|
|
|
// Render text slightly in front to avoid z-fighting
|
|
textTransform.postTranslate(glm::vec3(0.0f, 0.0f, SLIGHTLY_IN_FRONT * renderer->getFontSize()));
|
|
batch.setModelTransform(textTransform);
|
|
{
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__":renderText");
|
|
renderer->draw(batch, text_x, -text_y, nameUTF8.data(), textColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Avatar::setSkeletonOffset(const glm::vec3& offset) {
|
|
const float MAX_OFFSET_LENGTH = getModelScale() * 0.5f;
|
|
float offsetLength = glm::length(offset);
|
|
if (offsetLength > MAX_OFFSET_LENGTH) {
|
|
_skeletonOffset = (MAX_OFFSET_LENGTH / offsetLength) * offset;
|
|
} else {
|
|
_skeletonOffset = offset;
|
|
}
|
|
}
|
|
|
|
glm::vec3 Avatar::getSkeletonPosition() const {
|
|
// The avatar is rotated PI about the yAxis, so we have to correct for it
|
|
// to get the skeleton offset contribution in the world-frame.
|
|
const glm::quat FLIP = glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f));
|
|
return getWorldPosition() + getWorldOrientation() * FLIP * _skeletonOffset;
|
|
}
|
|
|
|
QVector<glm::quat> Avatar::getJointRotations() const {
|
|
if (QThread::currentThread() != thread()) {
|
|
return AvatarData::getJointRotations();
|
|
}
|
|
QVector<glm::quat> jointRotations(_skeletonModel->getJointStateCount());
|
|
for (int i = 0; i < _skeletonModel->getJointStateCount(); ++i) {
|
|
_skeletonModel->getJointRotation(i, jointRotations[i]);
|
|
}
|
|
return jointRotations;
|
|
}
|
|
|
|
QVector<glm::vec3> Avatar::getJointTranslations() const {
|
|
if (QThread::currentThread() != thread()) {
|
|
return AvatarData::getJointTranslations();
|
|
}
|
|
QVector<glm::vec3> jointTranslations(_skeletonModel->getJointStateCount());
|
|
for (int i = 0; i < _skeletonModel->getJointStateCount(); ++i) {
|
|
_skeletonModel->getJointTranslation(i, jointTranslations[i]);
|
|
}
|
|
return jointTranslations;
|
|
}
|
|
|
|
glm::quat Avatar::getJointRotation(int index) const {
|
|
glm::quat rotation;
|
|
_skeletonModel->getJointRotation(index, rotation);
|
|
return rotation;
|
|
}
|
|
|
|
glm::vec3 Avatar::getJointTranslation(int index) const {
|
|
glm::vec3 translation;
|
|
_skeletonModel->getJointTranslation(index, translation);
|
|
return translation;
|
|
}
|
|
|
|
glm::quat Avatar::getDefaultJointRotation(int index) const {
|
|
glm::quat rotation;
|
|
_skeletonModel->getRelativeDefaultJointRotation(index, rotation);
|
|
return rotation;
|
|
}
|
|
|
|
glm::vec3 Avatar::getDefaultJointTranslation(int index) const {
|
|
glm::vec3 translation;
|
|
_skeletonModel->getRelativeDefaultJointTranslation(index, translation);
|
|
return translation;
|
|
}
|
|
|
|
glm::quat Avatar::getAbsoluteDefaultJointRotationInObjectFrame(int index) const {
|
|
// To make this thread safe, we hold onto the model by smart ptr, which prevents it from being deleted while we are accessing it.
|
|
auto model = getSkeletonModel();
|
|
if (model) {
|
|
auto skeleton = model->getRig().getAnimSkeleton();
|
|
if (skeleton && index >= 0 && index < skeleton->getNumJoints()) {
|
|
// The rotation part of the geometry-to-rig transform is always identity so we can skip it.
|
|
// Y_180 is to convert from rig-frame into avatar-frame
|
|
return Quaternions::Y_180 * skeleton->getAbsoluteDefaultPose(index).rot();
|
|
}
|
|
}
|
|
return Quaternions::Y_180;
|
|
}
|
|
|
|
glm::vec3 Avatar::getAbsoluteDefaultJointTranslationInObjectFrame(int index) const {
|
|
// To make this thread safe, we hold onto the model by smart ptr, which prevents it from being deleted while we are accessing it.
|
|
auto model = getSkeletonModel();
|
|
if (model) {
|
|
const Rig& rig = model->getRig();
|
|
auto skeleton = rig.getAnimSkeleton();
|
|
if (skeleton && index >= 0 && index < skeleton->getNumJoints()) {
|
|
// trans is in geometry frame.
|
|
glm::vec3 trans = skeleton->getAbsoluteDefaultPose(index).trans();
|
|
// Y_180 is to convert from rig-frame into avatar-frame
|
|
glm::mat4 geomToAvatarMat = Matrices::Y_180 * rig.getGeometryToRigTransform();
|
|
return transformPoint(geomToAvatarMat, trans);
|
|
}
|
|
}
|
|
return Vectors::ZERO;
|
|
}
|
|
|
|
glm::quat Avatar::getAbsoluteJointRotationInObjectFrame(int index) const {
|
|
if (index < 0) {
|
|
index += numeric_limits<unsigned short>::max() + 1; // 65536
|
|
}
|
|
|
|
switch (index) {
|
|
case SENSOR_TO_WORLD_MATRIX_INDEX: {
|
|
glm::mat4 sensorToWorldMatrix = getSensorToWorldMatrix();
|
|
glm::mat4 avatarMatrix = getLocalTransform().getMatrix();
|
|
glm::mat4 finalMat = glm::inverse(avatarMatrix) * sensorToWorldMatrix;
|
|
return glmExtractRotation(finalMat);
|
|
}
|
|
case CAMERA_RELATIVE_CONTROLLER_LEFTHAND_INDEX:
|
|
case CONTROLLER_LEFTHAND_INDEX: {
|
|
Transform controllerLeftHandTransform = Transform(getControllerLeftHandMatrix());
|
|
return controllerLeftHandTransform.getRotation();
|
|
}
|
|
case CAMERA_RELATIVE_CONTROLLER_RIGHTHAND_INDEX:
|
|
case CONTROLLER_RIGHTHAND_INDEX: {
|
|
Transform controllerRightHandTransform = Transform(getControllerRightHandMatrix());
|
|
return controllerRightHandTransform.getRotation();
|
|
}
|
|
case CAMERA_MATRIX_INDEX: {
|
|
glm::quat rotation;
|
|
if (_skeletonModel && _skeletonModel->isActive()) {
|
|
int headJointIndex = _skeletonModel->getFBXGeometry().headJointIndex;
|
|
if (headJointIndex >= 0) {
|
|
_skeletonModel->getAbsoluteJointRotationInRigFrame(headJointIndex, rotation);
|
|
}
|
|
}
|
|
return Quaternions::Y_180 * rotation * Quaternions::Y_180;
|
|
}
|
|
default: {
|
|
glm::quat rotation;
|
|
_skeletonModel->getAbsoluteJointRotationInRigFrame(index, rotation);
|
|
return Quaternions::Y_180 * rotation;
|
|
}
|
|
}
|
|
}
|
|
|
|
glm::vec3 Avatar::getAbsoluteJointTranslationInObjectFrame(int index) const {
|
|
if (index < 0) {
|
|
index += numeric_limits<unsigned short>::max() + 1; // 65536
|
|
}
|
|
|
|
switch (index) {
|
|
case SENSOR_TO_WORLD_MATRIX_INDEX: {
|
|
glm::mat4 sensorToWorldMatrix = getSensorToWorldMatrix();
|
|
glm::mat4 avatarMatrix = getLocalTransform().getMatrix();
|
|
glm::mat4 finalMat = glm::inverse(avatarMatrix) * sensorToWorldMatrix;
|
|
return extractTranslation(finalMat);
|
|
}
|
|
case CAMERA_RELATIVE_CONTROLLER_LEFTHAND_INDEX:
|
|
case CONTROLLER_LEFTHAND_INDEX: {
|
|
Transform controllerLeftHandTransform = Transform(getControllerLeftHandMatrix());
|
|
return controllerLeftHandTransform.getTranslation();
|
|
}
|
|
case CAMERA_RELATIVE_CONTROLLER_RIGHTHAND_INDEX:
|
|
case CONTROLLER_RIGHTHAND_INDEX: {
|
|
Transform controllerRightHandTransform = Transform(getControllerRightHandMatrix());
|
|
return controllerRightHandTransform.getTranslation();
|
|
}
|
|
case CAMERA_MATRIX_INDEX: {
|
|
glm::vec3 translation;
|
|
if (_skeletonModel && _skeletonModel->isActive()) {
|
|
int headJointIndex = _skeletonModel->getFBXGeometry().headJointIndex;
|
|
if (headJointIndex >= 0) {
|
|
_skeletonModel->getAbsoluteJointTranslationInRigFrame(headJointIndex, translation);
|
|
}
|
|
}
|
|
return Quaternions::Y_180 * translation * Quaternions::Y_180;
|
|
}
|
|
default: {
|
|
glm::vec3 translation;
|
|
_skeletonModel->getAbsoluteJointTranslationInRigFrame(index, translation);
|
|
return Quaternions::Y_180 * translation;
|
|
}
|
|
}
|
|
}
|
|
|
|
glm::vec3 Avatar::getAbsoluteJointScaleInObjectFrame(int index) const {
|
|
if (index < 0) {
|
|
index += numeric_limits<unsigned short>::max() + 1; // 65536
|
|
}
|
|
|
|
// only sensor to world matrix has non identity scale.
|
|
switch (index) {
|
|
case SENSOR_TO_WORLD_MATRIX_INDEX: {
|
|
glm::mat4 sensorToWorldMatrix = getSensorToWorldMatrix();
|
|
return extractScale(sensorToWorldMatrix);
|
|
}
|
|
default:
|
|
return AvatarData::getAbsoluteJointScaleInObjectFrame(index);
|
|
}
|
|
}
|
|
|
|
void Avatar::invalidateJointIndicesCache() const {
|
|
QWriteLocker writeLock(&_modelJointIndicesCacheLock);
|
|
_modelJointsCached = false;
|
|
}
|
|
|
|
void Avatar::withValidJointIndicesCache(std::function<void()> const& worker) const {
|
|
QReadLocker readLock(&_modelJointIndicesCacheLock);
|
|
if (_modelJointsCached) {
|
|
worker();
|
|
} else {
|
|
readLock.unlock();
|
|
{
|
|
QWriteLocker writeLock(&_modelJointIndicesCacheLock);
|
|
if (!_modelJointsCached) {
|
|
_modelJointIndicesCache.clear();
|
|
if (_skeletonModel && _skeletonModel->isActive()) {
|
|
_modelJointIndicesCache = _skeletonModel->getFBXGeometry().jointIndices;
|
|
_modelJointsCached = true;
|
|
}
|
|
}
|
|
worker();
|
|
}
|
|
}
|
|
}
|
|
|
|
int Avatar::getJointIndex(const QString& name) const {
|
|
int result = getFauxJointIndex(name);
|
|
if (result != -1) {
|
|
return result;
|
|
}
|
|
|
|
withValidJointIndicesCache([&]() {
|
|
if (_modelJointIndicesCache.contains(name)) {
|
|
result = _modelJointIndicesCache[name] - 1;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
QStringList Avatar::getJointNames() const {
|
|
QStringList result;
|
|
withValidJointIndicesCache([&]() {
|
|
// find out how large the vector needs to be
|
|
int maxJointIndex = -1;
|
|
QHashIterator<QString, int> k(_modelJointIndicesCache);
|
|
while (k.hasNext()) {
|
|
k.next();
|
|
int index = k.value();
|
|
if (index > maxJointIndex) {
|
|
maxJointIndex = index;
|
|
}
|
|
}
|
|
// iterate through the hash and put joint names
|
|
// into the vector at their indices
|
|
QVector<QString> resultVector(maxJointIndex+1);
|
|
QHashIterator<QString, int> i(_modelJointIndicesCache);
|
|
while (i.hasNext()) {
|
|
i.next();
|
|
int index = i.value();
|
|
resultVector[index] = i.key();
|
|
}
|
|
// convert to QList and drop out blanks
|
|
result = resultVector.toList();
|
|
QMutableListIterator<QString> j(result);
|
|
while (j.hasNext()) {
|
|
QString jointName = j.next();
|
|
if (jointName.isEmpty()) {
|
|
j.remove();
|
|
}
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
glm::vec3 Avatar::getJointPosition(int index) const {
|
|
glm::vec3 position;
|
|
_skeletonModel->getJointPositionInWorldFrame(index, position);
|
|
return position;
|
|
}
|
|
|
|
glm::vec3 Avatar::getJointPosition(const QString& name) const {
|
|
glm::vec3 position;
|
|
_skeletonModel->getJointPositionInWorldFrame(getJointIndex(name), position);
|
|
return position;
|
|
}
|
|
|
|
void Avatar::scaleVectorRelativeToPosition(glm::vec3 &positionToScale) const {
|
|
//Scale a world space vector as if it was relative to the position
|
|
positionToScale = getWorldPosition() + getModelScale() * (positionToScale - getWorldPosition());
|
|
}
|
|
|
|
void Avatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
|
|
AvatarData::setSkeletonModelURL(skeletonModelURL);
|
|
if (QThread::currentThread() == thread()) {
|
|
_skeletonModel->setURL(_skeletonModelURL);
|
|
} else {
|
|
QMetaObject::invokeMethod(_skeletonModel.get(), "setURL", Qt::QueuedConnection, Q_ARG(QUrl, _skeletonModelURL));
|
|
}
|
|
}
|
|
|
|
void Avatar::setModelURLFinished(bool success) {
|
|
invalidateJointIndicesCache();
|
|
|
|
_isAnimatingScale = true;
|
|
_reconstructSoftEntitiesJointMap = true;
|
|
|
|
if (!success && _skeletonModelURL != AvatarData::defaultFullAvatarModelUrl()) {
|
|
const int MAX_SKELETON_DOWNLOAD_ATTEMPTS = 4; // NOTE: we don't want to be as generous as ResourceCache is, we only want 4 attempts
|
|
if (_skeletonModel->getResourceDownloadAttemptsRemaining() <= 0 ||
|
|
_skeletonModel->getResourceDownloadAttempts() > MAX_SKELETON_DOWNLOAD_ATTEMPTS) {
|
|
qCWarning(avatars_renderer) << "Using default after failing to load Avatar model: " << _skeletonModelURL
|
|
<< "after" << _skeletonModel->getResourceDownloadAttempts() << "attempts.";
|
|
// call _skeletonModel.setURL, but leave our copy of _skeletonModelURL alone. This is so that
|
|
// we don't redo this every time we receive an identity packet from the avatar with the bad url.
|
|
QMetaObject::invokeMethod(_skeletonModel.get(), "setURL",
|
|
Qt::QueuedConnection, Q_ARG(QUrl, AvatarData::defaultFullAvatarModelUrl()));
|
|
} else {
|
|
qCWarning(avatars_renderer) << "Avatar model: " << _skeletonModelURL
|
|
<< "failed to load... attempts:" << _skeletonModel->getResourceDownloadAttempts()
|
|
<< "out of:" << MAX_SKELETON_DOWNLOAD_ATTEMPTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
// rig is ready
|
|
void Avatar::rigReady() {
|
|
buildUnscaledEyeHeightCache();
|
|
}
|
|
|
|
// rig has been reset.
|
|
void Avatar::rigReset() {
|
|
clearUnscaledEyeHeightCache();
|
|
}
|
|
|
|
// create new model, can return an instance of a SoftAttachmentModel rather then Model
|
|
static std::shared_ptr<Model> allocateAttachmentModel(bool isSoft, const Rig& rigOverride, bool isCauterized) {
|
|
if (isSoft) {
|
|
// cast to std::shared_ptr<Model>
|
|
std::shared_ptr<SoftAttachmentModel> softModel = std::make_shared<SoftAttachmentModel>(nullptr, rigOverride);
|
|
if (isCauterized) {
|
|
softModel->flagAsCauterized();
|
|
}
|
|
return std::dynamic_pointer_cast<Model>(softModel);
|
|
} else {
|
|
return std::make_shared<Model>();
|
|
}
|
|
}
|
|
|
|
void Avatar::setAttachmentData(const QVector<AttachmentData>& attachmentData) {
|
|
if (QThread::currentThread() != thread()) {
|
|
BLOCKING_INVOKE_METHOD(this, "setAttachmentData",
|
|
Q_ARG(const QVector<AttachmentData>, attachmentData));
|
|
return;
|
|
}
|
|
|
|
auto oldAttachmentData = _attachmentData;
|
|
AvatarData::setAttachmentData(attachmentData);
|
|
|
|
// if number of attachments has been reduced, remove excess models.
|
|
while ((int)_attachmentModels.size() > attachmentData.size()) {
|
|
auto attachmentModel = _attachmentModels.back();
|
|
_attachmentModels.pop_back();
|
|
_attachmentModelsTexturesLoaded.pop_back();
|
|
_attachmentsToRemove.push_back(attachmentModel);
|
|
}
|
|
|
|
for (int i = 0; i < attachmentData.size(); i++) {
|
|
if (i == (int)_attachmentModels.size()) {
|
|
// if number of attachments has been increased, we need to allocate a new model
|
|
_attachmentModels.push_back(allocateAttachmentModel(attachmentData[i].isSoft, _skeletonModel->getRig(), isMyAvatar()));
|
|
_attachmentModelsTexturesLoaded.push_back(false);
|
|
} else if (i < oldAttachmentData.size() && oldAttachmentData[i].isSoft != attachmentData[i].isSoft) {
|
|
// if the attachment has changed type, we need to re-allocate a new one.
|
|
_attachmentsToRemove.push_back(_attachmentModels[i]);
|
|
_attachmentModels[i] = allocateAttachmentModel(attachmentData[i].isSoft, _skeletonModel->getRig(), isMyAvatar());
|
|
_attachmentModelsTexturesLoaded[i] = false;
|
|
}
|
|
// If the model URL has changd, we need to wait for the textures to load
|
|
if (_attachmentModels[i]->getURL() != attachmentData[i].modelURL) {
|
|
_attachmentModelsTexturesLoaded[i] = false;
|
|
}
|
|
_attachmentModels[i]->setURL(attachmentData[i].modelURL);
|
|
}
|
|
}
|
|
|
|
|
|
int Avatar::parseDataFromBuffer(const QByteArray& buffer) {
|
|
PerformanceTimer perfTimer("unpack");
|
|
if (!_initialized) {
|
|
// now that we have data for this Avatar we are go for init
|
|
init();
|
|
}
|
|
|
|
// change in position implies movement
|
|
glm::vec3 oldPosition = getWorldPosition();
|
|
|
|
int bytesRead = AvatarData::parseDataFromBuffer(buffer);
|
|
|
|
const float MOVE_DISTANCE_THRESHOLD = 0.001f;
|
|
_moving = glm::distance(oldPosition, getWorldPosition()) > MOVE_DISTANCE_THRESHOLD;
|
|
if (_moving) {
|
|
addPhysicsFlags(Simulation::DIRTY_POSITION);
|
|
}
|
|
if (_moving || _hasNewJointData) {
|
|
locationChanged();
|
|
}
|
|
|
|
return bytesRead;
|
|
}
|
|
|
|
int Avatar::_jointConesID = GeometryCache::UNKNOWN_ID;
|
|
|
|
// render a makeshift cone section that serves as a body part connecting joint spheres
|
|
void Avatar::renderJointConnectingCone(gpu::Batch& batch, glm::vec3 position1, glm::vec3 position2,
|
|
float radius1, float radius2, const glm::vec4& color) {
|
|
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
|
|
if (_jointConesID == GeometryCache::UNKNOWN_ID) {
|
|
_jointConesID = geometryCache->allocateID();
|
|
}
|
|
|
|
glm::vec3 axis = position2 - position1;
|
|
float length = glm::length(axis);
|
|
|
|
if (length > 0.0f) {
|
|
|
|
axis /= length;
|
|
|
|
glm::vec3 perpSin = glm::vec3(1.0f, 0.0f, 0.0f);
|
|
glm::vec3 perpCos = glm::normalize(glm::cross(axis, perpSin));
|
|
perpSin = glm::cross(perpCos, axis);
|
|
|
|
float angleb = 0.0f;
|
|
QVector<glm::vec3> points;
|
|
|
|
for (int i = 0; i < NUM_BODY_CONE_SIDES; i ++) {
|
|
|
|
// the rectangles that comprise the sides of the cone section are
|
|
// referenced by "a" and "b" in one dimension, and "1", and "2" in the other dimension.
|
|
int anglea = angleb;
|
|
angleb = ((float)(i+1) / (float)NUM_BODY_CONE_SIDES) * TWO_PI;
|
|
|
|
float sa = sinf(anglea);
|
|
float sb = sinf(angleb);
|
|
float ca = cosf(anglea);
|
|
float cb = cosf(angleb);
|
|
|
|
glm::vec3 p1a = position1 + perpSin * sa * radius1 + perpCos * ca * radius1;
|
|
glm::vec3 p1b = position1 + perpSin * sb * radius1 + perpCos * cb * radius1;
|
|
glm::vec3 p2a = position2 + perpSin * sa * radius2 + perpCos * ca * radius2;
|
|
glm::vec3 p2b = position2 + perpSin * sb * radius2 + perpCos * cb * radius2;
|
|
|
|
points << p1a << p1b << p2a << p1b << p2a << p2b;
|
|
}
|
|
|
|
PROFILE_RANGE_BATCH(batch, __FUNCTION__);
|
|
// TODO: this is really inefficient constantly recreating these vertices buffers. It would be
|
|
// better if the avatars cached these buffers for each of the joints they are rendering
|
|
geometryCache->updateVertices(_jointConesID, points, color);
|
|
geometryCache->renderVertices(batch, gpu::TRIANGLES, _jointConesID);
|
|
}
|
|
}
|
|
|
|
float Avatar::getSkeletonHeight() const {
|
|
Extents extents = _skeletonModel->getBindExtents();
|
|
return extents.maximum.y - extents.minimum.y;
|
|
}
|
|
|
|
float Avatar::getHeadHeight() const {
|
|
Extents extents = _skeletonModel->getMeshExtents();
|
|
glm::vec3 neckPosition;
|
|
if (!extents.isEmpty() && extents.isValid() && _skeletonModel->getNeckPosition(neckPosition)) {
|
|
return extents.maximum.y / 2.0f - neckPosition.y + getWorldPosition().y;
|
|
}
|
|
|
|
const float DEFAULT_HEAD_HEIGHT = 0.25f;
|
|
return DEFAULT_HEAD_HEIGHT;
|
|
}
|
|
|
|
float Avatar::getPelvisFloatingHeight() const {
|
|
return -_skeletonModel->getBindExtents().minimum.y;
|
|
}
|
|
|
|
void Avatar::updateDisplayNameAlpha(bool showDisplayName) {
|
|
if (!(showNamesAboveHeads || showReceiveStats)) {
|
|
_displayNameAlpha = 0.0f;
|
|
return;
|
|
}
|
|
|
|
// For myAvatar, the alpha update is not done (called in simulate for other avatars)
|
|
if (isMyAvatar()) {
|
|
if (showDisplayName) {
|
|
_displayNameAlpha = DISPLAYNAME_ALPHA;
|
|
} else {
|
|
_displayNameAlpha = 0.0f;
|
|
}
|
|
}
|
|
|
|
if (showDisplayName) {
|
|
_displayNameTargetAlpha = DISPLAYNAME_ALPHA;
|
|
} else {
|
|
_displayNameTargetAlpha = 0.0f;
|
|
}
|
|
}
|
|
|
|
// virtual
|
|
void Avatar::computeShapeInfo(ShapeInfo& shapeInfo) {
|
|
float uniformScale = getModelScale();
|
|
shapeInfo.setCapsuleY(uniformScale * _skeletonModel->getBoundingCapsuleRadius(),
|
|
0.5f * uniformScale * _skeletonModel->getBoundingCapsuleHeight());
|
|
shapeInfo.setOffset(uniformScale * _skeletonModel->getBoundingCapsuleOffset());
|
|
}
|
|
|
|
void Avatar::getCapsule(glm::vec3& start, glm::vec3& end, float& radius) {
|
|
ShapeInfo shapeInfo;
|
|
computeShapeInfo(shapeInfo);
|
|
glm::vec3 halfExtents = shapeInfo.getHalfExtents(); // x = radius, y = halfHeight
|
|
start = getWorldPosition() - glm::vec3(0, halfExtents.y, 0) + shapeInfo.getOffset();
|
|
end = getWorldPosition() + glm::vec3(0, halfExtents.y, 0) + shapeInfo.getOffset();
|
|
radius = halfExtents.x;
|
|
}
|
|
|
|
float Avatar::computeMass() {
|
|
float radius;
|
|
glm::vec3 start, end;
|
|
getCapsule(start, end, radius);
|
|
// NOTE:
|
|
// volumeOfCapsule = volumeOfCylinder + volumeOfSphere
|
|
// volumeOfCapsule = (2PI * R^2 * H) + (4PI * R^3 / 3)
|
|
// volumeOfCapsule = 2PI * R^2 * (H + 2R/3)
|
|
return _density * TWO_PI * radius * radius * (glm::length(end - start) + 2.0f * radius / 3.0f);
|
|
}
|
|
|
|
// virtual
|
|
void Avatar::rebuildCollisionShape() {
|
|
addPhysicsFlags(Simulation::DIRTY_SHAPE);
|
|
}
|
|
|
|
void Avatar::setPhysicsCallback(AvatarPhysicsCallback cb) {
|
|
_physicsCallback = cb;
|
|
}
|
|
|
|
void Avatar::addPhysicsFlags(uint32_t flags) {
|
|
if (_physicsCallback) {
|
|
_physicsCallback(flags);
|
|
}
|
|
}
|
|
|
|
// thread-safe
|
|
glm::vec3 Avatar::getLeftPalmPosition() const {
|
|
return _leftPalmPositionCache.get();
|
|
}
|
|
|
|
// thread-safe
|
|
glm::quat Avatar::getLeftPalmRotation() const {
|
|
return _leftPalmRotationCache.get();
|
|
}
|
|
|
|
// thread-safe
|
|
glm::vec3 Avatar::getRightPalmPosition() const {
|
|
return _rightPalmPositionCache.get();
|
|
}
|
|
|
|
// thread-safe
|
|
glm::quat Avatar::getRightPalmRotation() const {
|
|
return _rightPalmRotationCache.get();
|
|
}
|
|
|
|
glm::vec3 Avatar::getUncachedLeftPalmPosition() const {
|
|
assert(QThread::currentThread() == thread()); // main thread access only
|
|
glm::quat leftPalmRotation;
|
|
glm::vec3 leftPalmPosition;
|
|
if (_skeletonModel->getLeftGrabPosition(leftPalmPosition)) {
|
|
return leftPalmPosition;
|
|
}
|
|
// avatar didn't have a LeftHandMiddle1 joint, fall back on this:
|
|
_skeletonModel->getJointRotationInWorldFrame(_skeletonModel->getLeftHandJointIndex(), leftPalmRotation);
|
|
_skeletonModel->getLeftHandPosition(leftPalmPosition);
|
|
leftPalmPosition += HAND_TO_PALM_OFFSET * glm::inverse(leftPalmRotation);
|
|
return leftPalmPosition;
|
|
}
|
|
|
|
glm::quat Avatar::getUncachedLeftPalmRotation() const {
|
|
assert(QThread::currentThread() == thread()); // main thread access only
|
|
glm::quat leftPalmRotation;
|
|
_skeletonModel->getJointRotationInWorldFrame(_skeletonModel->getLeftHandJointIndex(), leftPalmRotation);
|
|
return leftPalmRotation;
|
|
}
|
|
|
|
glm::vec3 Avatar::getUncachedRightPalmPosition() const {
|
|
assert(QThread::currentThread() == thread()); // main thread access only
|
|
glm::quat rightPalmRotation;
|
|
glm::vec3 rightPalmPosition;
|
|
if (_skeletonModel->getRightGrabPosition(rightPalmPosition)) {
|
|
return rightPalmPosition;
|
|
}
|
|
// avatar didn't have a RightHandMiddle1 joint, fall back on this:
|
|
_skeletonModel->getJointRotationInWorldFrame(_skeletonModel->getRightHandJointIndex(), rightPalmRotation);
|
|
_skeletonModel->getRightHandPosition(rightPalmPosition);
|
|
rightPalmPosition += HAND_TO_PALM_OFFSET * glm::inverse(rightPalmRotation);
|
|
return rightPalmPosition;
|
|
}
|
|
|
|
glm::quat Avatar::getUncachedRightPalmRotation() const {
|
|
assert(QThread::currentThread() == thread()); // main thread access only
|
|
glm::quat rightPalmRotation;
|
|
_skeletonModel->getJointRotationInWorldFrame(_skeletonModel->getRightHandJointIndex(), rightPalmRotation);
|
|
return rightPalmRotation;
|
|
}
|
|
|
|
void Avatar::setPositionViaScript(const glm::vec3& position) {
|
|
setWorldPosition(position);
|
|
updateAttitude(getWorldOrientation());
|
|
}
|
|
|
|
void Avatar::setOrientationViaScript(const glm::quat& orientation) {
|
|
setWorldOrientation(orientation);
|
|
updateAttitude(orientation);
|
|
}
|
|
|
|
void Avatar::updatePalms() {
|
|
PerformanceTimer perfTimer("palms");
|
|
// update thread-safe caches
|
|
_leftPalmRotationCache.set(getUncachedLeftPalmRotation());
|
|
_rightPalmRotationCache.set(getUncachedRightPalmRotation());
|
|
_leftPalmPositionCache.set(getUncachedLeftPalmPosition());
|
|
_rightPalmPositionCache.set(getUncachedRightPalmPosition());
|
|
}
|
|
|
|
void Avatar::setParentID(const QUuid& parentID) {
|
|
if (!isMyAvatar()) {
|
|
return;
|
|
}
|
|
QUuid initialParentID = getParentID();
|
|
bool success;
|
|
Transform beforeChangeTransform = getTransform(success);
|
|
SpatiallyNestable::setParentID(parentID);
|
|
if (success) {
|
|
setTransform(beforeChangeTransform, success);
|
|
if (!success) {
|
|
qCDebug(avatars_renderer) << "Avatar::setParentID failed to reset avatar's location.";
|
|
}
|
|
if (initialParentID != parentID) {
|
|
_parentChanged = usecTimestampNow();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Avatar::setParentJointIndex(quint16 parentJointIndex) {
|
|
if (!isMyAvatar()) {
|
|
return;
|
|
}
|
|
bool success;
|
|
Transform beforeChangeTransform = getTransform(success);
|
|
SpatiallyNestable::setParentJointIndex(parentJointIndex);
|
|
if (success) {
|
|
setTransform(beforeChangeTransform, success);
|
|
if (!success) {
|
|
qCDebug(avatars_renderer) << "Avatar::setParentJointIndex failed to reset avatar's location.";
|
|
}
|
|
}
|
|
}
|
|
|
|
QList<QVariant> Avatar::getSkeleton() {
|
|
SkeletonModelPointer skeletonModel = _skeletonModel;
|
|
if (skeletonModel) {
|
|
const Rig& rig = skeletonModel->getRig();
|
|
AnimSkeleton::ConstPointer skeleton = rig.getAnimSkeleton();
|
|
if (skeleton) {
|
|
QList<QVariant> list;
|
|
list.reserve(skeleton->getNumJoints());
|
|
for (int i = 0; i < skeleton->getNumJoints(); i++) {
|
|
QVariantMap obj;
|
|
obj["name"] = skeleton->getJointName(i);
|
|
obj["index"] = i;
|
|
obj["parentIndex"] = skeleton->getParentIndex(i);
|
|
list.push_back(obj);
|
|
}
|
|
return list;
|
|
}
|
|
}
|
|
|
|
return QList<QVariant>();
|
|
}
|
|
|
|
void Avatar::addToScene(AvatarSharedPointer myHandle, const render::ScenePointer& scene) {
|
|
if (scene) {
|
|
auto nodelist = DependencyManager::get<NodeList>();
|
|
if (showAvatars
|
|
&& !nodelist->isIgnoringNode(getSessionUUID())) {
|
|
render::Transaction transaction;
|
|
addToScene(myHandle, scene, transaction);
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
} else {
|
|
qCWarning(avatars_renderer) << "Avatar::addAvatar() : Unexpected null scene, possibly during application shutdown";
|
|
}
|
|
}
|
|
|
|
void Avatar::ensureInScene(AvatarSharedPointer self, const render::ScenePointer& scene) {
|
|
if (!render::Item::isValidID(_renderItemID)) {
|
|
addToScene(self, scene);
|
|
}
|
|
}
|
|
|
|
// thread-safe
|
|
float Avatar::getEyeHeight() const {
|
|
return getModelScale() * getUnscaledEyeHeight();
|
|
}
|
|
|
|
// thread-safe
|
|
float Avatar::getUnscaledEyeHeight() const {
|
|
return _unscaledEyeHeightCache.get();
|
|
}
|
|
|
|
void Avatar::buildUnscaledEyeHeightCache() {
|
|
float skeletonHeight = getUnscaledEyeHeightFromSkeleton();
|
|
|
|
// Sanity check by looking at the model extents.
|
|
Extents meshExtents = _skeletonModel->getUnscaledMeshExtents();
|
|
float meshHeight = meshExtents.size().y;
|
|
|
|
// if we determine the mesh is much larger then the skeleton, then we use the mesh height instead.
|
|
// This helps prevent absurdly large avatars from exceeding the domain height limit.
|
|
const float MESH_SLOP_RATIO = 1.5f;
|
|
if (meshHeight > skeletonHeight * MESH_SLOP_RATIO) {
|
|
_unscaledEyeHeightCache.set(meshHeight);
|
|
} else {
|
|
_unscaledEyeHeightCache.set(skeletonHeight);
|
|
}
|
|
}
|
|
|
|
void Avatar::clearUnscaledEyeHeightCache() {
|
|
_unscaledEyeHeightCache.set(DEFAULT_AVATAR_EYE_HEIGHT);
|
|
}
|
|
|
|
float Avatar::getUnscaledEyeHeightFromSkeleton() const {
|
|
|
|
// TODO: if performance becomes a concern we can cache this value rather then computing it everytime.
|
|
|
|
if (_skeletonModel) {
|
|
auto& rig = _skeletonModel->getRig();
|
|
|
|
// Normally the model offset transform will contain the avatar scale factor, we explicitly remove it here.
|
|
AnimPose modelOffsetWithoutAvatarScale(glm::vec3(1.0f), rig.getModelOffsetPose().rot(), rig.getModelOffsetPose().trans());
|
|
AnimPose geomToRigWithoutAvatarScale = modelOffsetWithoutAvatarScale * rig.getGeometryOffsetPose();
|
|
|
|
// This factor can be used to scale distances in the geometry frame into the unscaled rig frame.
|
|
// Typically it will be the unit conversion from cm to m.
|
|
float scaleFactor = geomToRigWithoutAvatarScale.scale().x; // in practice this always a uniform scale factor.
|
|
|
|
int headTopJoint = rig.indexOfJoint("HeadTop_End");
|
|
int headJoint = rig.indexOfJoint("Head");
|
|
int eyeJoint = rig.indexOfJoint("LeftEye") != -1 ? rig.indexOfJoint("LeftEye") : rig.indexOfJoint("RightEye");
|
|
int toeJoint = rig.indexOfJoint("LeftToeBase") != -1 ? rig.indexOfJoint("LeftToeBase") : rig.indexOfJoint("RightToeBase");
|
|
|
|
// Makes assumption that the y = 0 plane in geometry is the ground plane.
|
|
// We also make that assumption in Rig::computeAvatarBoundingCapsule()
|
|
const float GROUND_Y = 0.0f;
|
|
|
|
// Values from the skeleton are in the geometry coordinate frame.
|
|
auto skeleton = rig.getAnimSkeleton();
|
|
if (eyeJoint >= 0 && toeJoint >= 0) {
|
|
// Measure from eyes to toes.
|
|
float eyeHeight = skeleton->getAbsoluteDefaultPose(eyeJoint).trans().y - skeleton->getAbsoluteDefaultPose(toeJoint).trans().y;
|
|
return scaleFactor * eyeHeight;
|
|
} else if (eyeJoint >= 0) {
|
|
// Measure Eye joint to y = 0 plane.
|
|
float eyeHeight = skeleton->getAbsoluteDefaultPose(eyeJoint).trans().y - GROUND_Y;
|
|
return scaleFactor * eyeHeight;
|
|
} else if (headTopJoint >= 0 && toeJoint >= 0) {
|
|
// Measure from ToeBase joint to HeadTop_End joint, then remove forehead distance.
|
|
const float ratio = DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD / DEFAULT_AVATAR_HEIGHT;
|
|
float height = skeleton->getAbsoluteDefaultPose(headTopJoint).trans().y - skeleton->getAbsoluteDefaultPose(toeJoint).trans().y;
|
|
return scaleFactor * (height - height * ratio);
|
|
} else if (headTopJoint >= 0) {
|
|
// Measure from HeadTop_End joint to the ground, then remove forehead distance.
|
|
const float ratio = DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD / DEFAULT_AVATAR_HEIGHT;
|
|
float headHeight = skeleton->getAbsoluteDefaultPose(headTopJoint).trans().y - GROUND_Y;
|
|
return scaleFactor * (headHeight - headHeight * ratio);
|
|
} else if (headJoint >= 0) {
|
|
// Measure Head joint to the ground, then add in distance from neck to eye.
|
|
const float DEFAULT_AVATAR_NECK_TO_EYE = DEFAULT_AVATAR_NECK_TO_TOP_OF_HEAD - DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD;
|
|
const float ratio = DEFAULT_AVATAR_NECK_TO_EYE / DEFAULT_AVATAR_NECK_HEIGHT;
|
|
float neckHeight = skeleton->getAbsoluteDefaultPose(headJoint).trans().y - GROUND_Y;
|
|
return scaleFactor * (neckHeight + neckHeight * ratio);
|
|
} else {
|
|
return DEFAULT_AVATAR_EYE_HEIGHT;
|
|
}
|
|
} else {
|
|
return DEFAULT_AVATAR_EYE_HEIGHT;
|
|
}
|
|
}
|