////  Created by Sam Gondelman 7/2/2018//  Copyright 2018 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 "ParabolaPick.h" #include "Application.h"#include "EntityScriptingInterface.h"#include "PickScriptingInterface.h"#include "avatar/AvatarManager.h"#include "scripting/HMDScriptingInterface.h"#include "DependencyManager.h"#include "PickManager.h" ParabolaPick::ParabolaPick(const glm::vec3& position, const glm::vec3& direction, float speed, const glm::vec3& accelerationAxis, bool rotateAccelerationWithAvatar, bool rotateAccelerationWithParent, bool scaleWithParent, const PickFilter& filter, float maxDistance, bool enabled) :    Pick(PickParabola(position, speed * direction, accelerationAxis), filter, maxDistance, enabled),    _rotateAccelerationWithAvatar(rotateAccelerationWithAvatar),    _rotateAccelerationWithParent(rotateAccelerationWithParent),    _scaleWithParent(scaleWithParent),    _speed(speed) {} PickParabola ParabolaPick::getMathematicalPick() const {    if (!parentTransform) {        PickParabola mathPick = _mathPick;        if (_rotateAccelerationWithAvatar) {            mathPick.acceleration = DependencyManager::get<AvatarManager>()->getMyAvatar()->getWorldOrientation() * mathPick.acceleration;        }        return mathPick;    }     Transform currentParentTransform = parentTransform->getTransform();     glm::vec3 position = currentParentTransform.transform(_mathPick.origin);    glm::vec3 velocity = _mathPick.velocity;    if (_scaleWithParent) {        velocity = currentParentTransform.transformDirection(velocity);    } else {        glm::vec3 transformedVelocity = currentParentTransform.transformDirection(velocity);        velocity = glm::normalize(transformedVelocity) * _speed;    }    glm::vec3 acceleration = _mathPick.acceleration;    if (_scaleWithParent) {        acceleration *= currentParentTransform.getScale();    }    if (_rotateAccelerationWithAvatar) {        acceleration = DependencyManager::get<AvatarManager>()->getMyAvatar()->getWorldOrientation() * acceleration;    } else if (_rotateAccelerationWithParent) {        acceleration = currentParentTransform.getRotation() * acceleration;    }     return PickParabola(position, velocity, acceleration);} PickResultPointer ParabolaPick::getEntityIntersection(const PickParabola& pick) {    if (glm::length2(pick.acceleration) > EPSILON && glm::length2(pick.velocity) > EPSILON) {        PickFilter searchFilter = getFilter();        if (DependencyManager::get<PickManager>()->getForceCoarsePicking()) {            searchFilter.setFlag(PickFilter::COARSE, true);            searchFilter.setFlag(PickFilter::PRECISE, false);        }         ParabolaToEntityIntersectionResult entityRes =            DependencyManager::get<EntityScriptingInterface>()->evalParabolaIntersectionVector(pick, searchFilter,                getIncludeItemsAs<EntityItemID>(), getIgnoreItemsAs<EntityItemID>());        if (entityRes.intersects) {            IntersectionType type = IntersectionType::ENTITY;            if (getFilter().doesPickLocalEntities()) {                EntityPropertyFlags desiredProperties;                desiredProperties += PROP_ENTITY_HOST_TYPE;                if (DependencyManager::get<EntityScriptingInterface>()->getEntityPropertiesInternal(entityRes.entityID, desiredProperties, false).getEntityHostType() == entity::HostType::LOCAL) {                    type = IntersectionType::LOCAL_ENTITY;                }            }            return std::make_shared<ParabolaPickResult>(type, entityRes.entityID, entityRes.distance, entityRes.parabolicDistance, entityRes.intersection, pick, entityRes.surfaceNormal, entityRes.extraInfo);        }    }    return std::make_shared<ParabolaPickResult>(pick.toVariantMap());} PickResultPointer ParabolaPick::getAvatarIntersection(const PickParabola& pick) {    if (glm::length2(pick.acceleration) > EPSILON && glm::length2(pick.velocity) > EPSILON) {        ParabolaToAvatarIntersectionResult avatarRes = DependencyManager::get<AvatarManager>()->findParabolaIntersectionVector(pick, getIncludeItemsAs<EntityItemID>(), getIgnoreItemsAs<EntityItemID>());        if (avatarRes.intersects) {            return std::make_shared<ParabolaPickResult>(IntersectionType::AVATAR, avatarRes.avatarID, avatarRes.distance, avatarRes.parabolicDistance, avatarRes.intersection, pick, avatarRes.surfaceNormal, avatarRes.extraInfo);        }    }    return std::make_shared<ParabolaPickResult>(pick.toVariantMap());} PickResultPointer ParabolaPick::getHUDIntersection(const PickParabola& pick) {    if (glm::length2(pick.acceleration) > EPSILON && glm::length2(pick.velocity) > EPSILON) {        float parabolicDistance;        glm::vec3 hudRes = DependencyManager::get<HMDScriptingInterface>()->calculateParabolaUICollisionPoint(pick.origin, pick.velocity, pick.acceleration, parabolicDistance);        return std::make_shared<ParabolaPickResult>(IntersectionType::HUD, QUuid(), glm::distance(pick.origin, hudRes), parabolicDistance, hudRes, pick);    }    return std::make_shared<ParabolaPickResult>(pick.toVariantMap());} Transform ParabolaPick::getResultTransform() const {    PickResultPointer result = getPrevPickResult();    if (!result) {        return Transform();    }     auto parabolaResult = std::static_pointer_cast<ParabolaPickResult>(result);    Transform transform;    transform.setTranslation(parabolaResult->intersection);    return transform;}