mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-06-25 13:30:10 +02:00
282 lines
13 KiB
C++
282 lines
13 KiB
C++
//
|
|
// MovingEntitiesOperator.cpp
|
|
// libraries/entities/src
|
|
//
|
|
// Created by Brad Hefta-Gaub on 8/11/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
|
|
//
|
|
|
|
#include "EntityItem.h"
|
|
#include "EntityTree.h"
|
|
#include "EntityTreeElement.h"
|
|
|
|
#include "MovingEntitiesOperator.h"
|
|
|
|
MovingEntitiesOperator::MovingEntitiesOperator(EntityTree* tree) :
|
|
_tree(tree),
|
|
_changeTime(usecTimestampNow()),
|
|
_foundOldCount(0),
|
|
_foundNewCount(0),
|
|
_lookingCount(0),
|
|
_wantDebug(false)
|
|
{
|
|
}
|
|
|
|
MovingEntitiesOperator::~MovingEntitiesOperator() {
|
|
if (_wantDebug) {
|
|
bool stopExecution = false;
|
|
qDebug() << "MovingEntitiesOperator::~MovingEntitiesOperator() -----------------------------";
|
|
qDebug() << " _lookingCount:" << _lookingCount;
|
|
qDebug() << " _foundOldCount:" << _foundOldCount;
|
|
qDebug() << " _foundNewCount:" << _foundNewCount;
|
|
if (_foundOldCount < _lookingCount) {
|
|
qDebug() << " FAILURE: **** _foundOldCount < _lookingCount ******";
|
|
stopExecution = true;
|
|
}
|
|
if (_foundNewCount < _lookingCount) {
|
|
qDebug() << " FAILURE: **** _foundNewCount < _lookingCount ******";
|
|
stopExecution = true;
|
|
}
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
if(stopExecution) {
|
|
debug();
|
|
assert(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void MovingEntitiesOperator::addEntityToMoveList(EntityItem* entity, const AACube& newCube) {
|
|
EntityTreeElement* oldContainingElement = _tree->getContainingElement(entity->getEntityItemID());
|
|
AABox newCubeClamped = newCube.clamp(0.0f, 1.0f);
|
|
|
|
if (_wantDebug) {
|
|
qDebug() << "MovingEntitiesOperator::addEntityToMoveList() -----------------------------";
|
|
qDebug() << " newCube:" << newCube;
|
|
qDebug() << " newCubeClamped:" << newCubeClamped;
|
|
if (oldContainingElement) {
|
|
qDebug() << " oldContainingElement:" << oldContainingElement->getAACube();
|
|
qDebug() << " oldContainingElement->bestFitBounds(newCubeClamped):"
|
|
<< oldContainingElement->bestFitBounds(newCubeClamped);
|
|
} else {
|
|
qDebug() << " WARNING NO OLD CONTAINING ELEMENT!!!";
|
|
}
|
|
}
|
|
|
|
if (!oldContainingElement) {
|
|
qDebug() << "UNEXPECTED!!!! attempting to move entity "<< entity->getEntityItemID()
|
|
<< "that has no containing element. ";
|
|
return; // bail without adding.
|
|
}
|
|
|
|
// If the original containing element is the best fit for the requested newCube locations then
|
|
// we don't actually need to add the entity for moving and we can short circuit all this work
|
|
if (!oldContainingElement->bestFitBounds(newCubeClamped)) {
|
|
// check our tree, to determine if this entity is known
|
|
EntityToMoveDetails details;
|
|
details.oldContainingElement = oldContainingElement;
|
|
details.oldContainingElementCube = oldContainingElement->getAACube();
|
|
details.entity = entity;
|
|
details.oldFound = false;
|
|
details.newFound = false;
|
|
details.newCube = newCube;
|
|
details.newCubeClamped = newCubeClamped;
|
|
_entitiesToMove << details;
|
|
_lookingCount++;
|
|
|
|
if (_wantDebug) {
|
|
qDebug() << "MovingEntitiesOperator::addEntityToMoveList() -----------------------------";
|
|
qDebug() << " details.entity:" << details.entity->getEntityItemID();
|
|
qDebug() << " details.oldContainingElementCube:" << details.oldContainingElementCube;
|
|
qDebug() << " details.newCube:" << details.newCube;
|
|
qDebug() << " details.newCubeClamped:" << details.newCubeClamped;
|
|
qDebug() << " _lookingCount:" << _lookingCount;
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
}
|
|
} else {
|
|
if (_wantDebug) {
|
|
qDebug() << " oldContainingElement->bestFitBounds(newCubeClamped) IS BEST FIT... NOTHING TO DO";
|
|
}
|
|
}
|
|
|
|
if (_wantDebug) {
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
}
|
|
}
|
|
|
|
// does this entity tree element contain the old entity
|
|
bool MovingEntitiesOperator::shouldRecurseSubTree(OctreeElement* element) {
|
|
bool containsEntity = false;
|
|
|
|
// If we don't have an old entity, then we don't contain the entity, otherwise
|
|
// check the bounds
|
|
if (_entitiesToMove.size() > 0) {
|
|
AACube elementCube = element->getAACube();
|
|
int detailIndex = 0;
|
|
foreach(const EntityToMoveDetails& details, _entitiesToMove) {
|
|
|
|
if (_wantDebug) {
|
|
qDebug() << "MovingEntitiesOperator::shouldRecurseSubTree() details["<< detailIndex <<"]-----------------------------";
|
|
qDebug() << " element:" << element->getAACube();
|
|
qDebug() << " details.entity:" << details.entity->getEntityItemID();
|
|
qDebug() << " details.oldContainingElementCube:" << details.oldContainingElementCube;
|
|
qDebug() << " details.newCube:" << details.newCube;
|
|
qDebug() << " details.newCubeClamped:" << details.newCubeClamped;
|
|
qDebug() << " elementCube.contains(details.newCube)" << elementCube.contains(details.newCube);
|
|
qDebug() << " elementCube.contains(details.newCubeClamped)" << elementCube.contains(details.newCubeClamped);
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
}
|
|
|
|
if (elementCube.contains(details.oldContainingElementCube) || elementCube.contains(details.newCubeClamped)) {
|
|
containsEntity = true;
|
|
break; // if it contains at least one, we're good to go
|
|
}
|
|
detailIndex++;
|
|
}
|
|
}
|
|
return containsEntity;
|
|
}
|
|
|
|
bool MovingEntitiesOperator::preRecursion(OctreeElement* element) {
|
|
EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element);
|
|
|
|
// In Pre-recursion, we're generally deciding whether or not we want to recurse this
|
|
// path of the tree. For this operation, we want to recurse the branch of the tree if
|
|
// and of the following are true:
|
|
// * We have not yet found the old entity, and this branch contains our old entity
|
|
// * We have not yet found the new entity, and this branch contains our new entity
|
|
//
|
|
// Note: it's often the case that the branch in question contains both the old entity
|
|
// and the new entity.
|
|
|
|
bool keepSearching = (_foundOldCount < _lookingCount) || (_foundNewCount < _lookingCount);
|
|
|
|
// If we haven't yet found all the entities, and this sub tree contains at least one of our
|
|
// entities, then we need to keep searching.
|
|
if (keepSearching && shouldRecurseSubTree(element)) {
|
|
|
|
// check against each of our search entities
|
|
int detailIndex = 0;
|
|
foreach(const EntityToMoveDetails& details, _entitiesToMove) {
|
|
|
|
if (_wantDebug) {
|
|
qDebug() << "MovingEntitiesOperator::preRecursion() details["<< detailIndex <<"]-----------------------------";
|
|
qDebug() << " entityTreeElement:" << entityTreeElement->getAACube();
|
|
qDebug() << " entityTreeElement->bestFitBounds(details.newCube):" << entityTreeElement->bestFitBounds(details.newCube);
|
|
qDebug() << " details.entity:" << details.entity->getEntityItemID();
|
|
qDebug() << " details.oldContainingElementCube:" << details.oldContainingElementCube;
|
|
qDebug() << " entityTreeElement:" << entityTreeElement;
|
|
qDebug() << " details.newCube:" << details.newCube;
|
|
qDebug() << " details.newCubeClamped:" << details.newCubeClamped;
|
|
qDebug() << " _lookingCount:" << _lookingCount;
|
|
qDebug() << " _foundOldCount:" << _foundOldCount;
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
}
|
|
|
|
|
|
// If this is one of the old elements we're looking for, then ask it to remove the old entity
|
|
if (!details.oldFound && entityTreeElement == details.oldContainingElement) {
|
|
entityTreeElement->removeEntityItem(details.entity);
|
|
_foundOldCount++;
|
|
//details.oldFound = true; // TODO: would be nice to add this optimization
|
|
if (_wantDebug) {
|
|
qDebug() << "MovingEntitiesOperator::preRecursion() -----------------------------";
|
|
qDebug() << " FOUND OLD - REMOVING";
|
|
qDebug() << " entityTreeElement == details.oldContainingElement";
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
}
|
|
}
|
|
|
|
// If this element is the best fit for the new bounds of this entity then add the entity to the element
|
|
if (!details.newFound && entityTreeElement->bestFitBounds(details.newCube)) {
|
|
EntityItemID entityItemID = details.entity->getEntityItemID();
|
|
entityTreeElement->addEntityItem(details.entity);
|
|
_tree->setContainingElement(entityItemID, entityTreeElement);
|
|
_foundNewCount++;
|
|
//details.newFound = true; // TODO: would be nice to add this optimization
|
|
if (_wantDebug) {
|
|
qDebug() << "MovingEntitiesOperator::preRecursion() -----------------------------";
|
|
qDebug() << " FOUND NEW - ADDING";
|
|
qDebug() << " entityTreeElement->bestFitBounds(details.newCube)";
|
|
qDebug() << "--------------------------------------------------------------------------";
|
|
}
|
|
}
|
|
detailIndex++;
|
|
}
|
|
// if we haven't found all of our search for entities, then keep looking
|
|
keepSearching = (_foundOldCount < _lookingCount) || (_foundNewCount < _lookingCount);
|
|
}
|
|
|
|
return keepSearching; // if we haven't yet found it, keep looking
|
|
}
|
|
|
|
bool MovingEntitiesOperator::postRecursion(OctreeElement* element) {
|
|
// Post-recursion is the unwinding process. For this operation, while we
|
|
// unwind we want to mark the path as being dirty if we changed it below.
|
|
// We might have two paths, one for the old entity and one for the new entity.
|
|
bool keepSearching = (_foundOldCount < _lookingCount) || (_foundNewCount < _lookingCount);
|
|
|
|
// As we unwind, if we're in either of these two paths, we mark our element
|
|
// as dirty.
|
|
if ((shouldRecurseSubTree(element))) {
|
|
element->markWithChangedTime();
|
|
}
|
|
|
|
|
|
|
|
// It's not OK to prune if we have the potential of deleting the original containig element.
|
|
// because if we prune the containing element then new might end up reallocating the same memory later
|
|
// and that will confuse our logic.
|
|
//
|
|
// it's ok to prune if:
|
|
// 2) this subtree doesn't contain any old elements
|
|
// 3) this subtree contains an old element, but this element isn't a direct parent of any old containing element
|
|
|
|
bool elementSubTreeContainsOldElements = false;
|
|
bool elementIsDirectParentOfOldElment = false;
|
|
foreach(const EntityToMoveDetails& details, _entitiesToMove) {
|
|
if (element->getAACube().contains(details.oldContainingElementCube)) {
|
|
elementSubTreeContainsOldElements = true;
|
|
}
|
|
if (element->isParentOf(details.oldContainingElement)) {
|
|
elementIsDirectParentOfOldElment = true;
|
|
}
|
|
}
|
|
if (!elementSubTreeContainsOldElements || !elementIsDirectParentOfOldElment) {
|
|
EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element);
|
|
entityTreeElement->pruneChildren(); // take this opportunity to prune any empty leaves
|
|
}
|
|
|
|
return keepSearching; // if we haven't yet found it, keep looking
|
|
}
|
|
|
|
OctreeElement* MovingEntitiesOperator::possiblyCreateChildAt(OctreeElement* element, int childIndex) {
|
|
// If we're getting called, it's because there was no child element at this index while recursing.
|
|
// We only care if this happens while still searching for the new entity locations.
|
|
if (_foundNewCount < _lookingCount) {
|
|
|
|
float childElementScale = element->getAACube().getScale() / 2.0f; // all of our children will be half our scale
|
|
|
|
// check against each of our entities
|
|
foreach(const EntityToMoveDetails& details, _entitiesToMove) {
|
|
|
|
// if the scale of our desired cube is smaller than our children, then consider making a child
|
|
if (details.newCubeClamped.getLargestDimension() <= childElementScale) {
|
|
|
|
int indexOfChildContainingNewEntity = element->getMyChildContaining(details.newCubeClamped);
|
|
|
|
// If the childIndex we were asked if we wanted to create contains this newCube,
|
|
// then we will create this branch and continue. We can exit this loop immediately
|
|
// because if we need this branch for any one entity then it doesn't matter if it's
|
|
// needed for more entities.
|
|
if (childIndex == indexOfChildContainingNewEntity) {
|
|
return element->addChildAtIndex(childIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|