// // ModelTree.cpp // libraries/models/src // // Created by Brad Hefta-Gaub on 12/4/13. // 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 "ModelTree.h" ModelTree::ModelTree(bool shouldReaverage) : Octree(shouldReaverage) { _rootElement = createNewElement(); } ModelTreeElement* ModelTree::createNewElement(unsigned char * octalCode) { ModelTreeElement* newElement = new ModelTreeElement(octalCode); newElement->setTree(this); return newElement; } void ModelTree::eraseAllOctreeElements() { _modelToElementMap.clear(); Octree::eraseAllOctreeElements(); } bool ModelTree::handlesEditPacketType(PacketType packetType) const { // we handle these types of "edit" packets switch (packetType) { case PacketTypeModelAddOrEdit: case PacketTypeModelErase: return true; default: return false; } } class StoreModelOperator : public RecurseOctreeOperator { public: StoreModelOperator(ModelTree* tree, const ModelItem& searchModel); virtual bool PreRecursion(OctreeElement* element); virtual bool PostRecursion(OctreeElement* element); virtual OctreeElement* PossiblyCreateChildAt(OctreeElement* element, int childIndex); private: ModelTree* _tree; const ModelItem& _newModel; const ModelItem* _oldModel; ModelTreeElement* _containingElement; bool _foundOld; bool _foundNew; quint64 _changeTime; bool subTreeContainsOldModel(OctreeElement* element); bool subTreeContainsNewModel(OctreeElement* element); }; StoreModelOperator::StoreModelOperator(ModelTree* tree, const ModelItem& searchModel) : _tree(tree), _newModel(searchModel), _oldModel(NULL), _containingElement(NULL), _foundOld(false), _foundNew(false), _changeTime(usecTimestampNow()) { // check our tree, to determine if this model is known _containingElement = _tree->getContainingElement(searchModel.getModelItemID()); if (_containingElement) { _oldModel = _containingElement->getModelWithModelItemID(searchModel.getModelItemID()); if (!_oldModel) { //assert(_oldModel); qDebug() << "that's UNEXPECTED, we got a _containingElement, but couldn't find the oldModel!"; } // If this containing element would be the best fit for our new model, then just do the new // portion of the store pass, since the change path will be the same for both parts of the update if (_containingElement->bestFitModelBounds(_newModel)) { _foundOld = true; } } else { // if the old model is not known, then we can consider if found, and // we'll only be searching for the new location _foundOld = true; } } // does this model tree element contain the old model bool StoreModelOperator::subTreeContainsOldModel(OctreeElement* element) { bool containsModel = false; // If we don't have an old model, then we don't contain the model, otherwise // check the bounds if (_oldModel) { AACube elementCube = element->getAACube(); AACube modelCube = _oldModel->getAACube(); containsModel = elementCube.contains(modelCube); } return containsModel; } bool StoreModelOperator::subTreeContainsNewModel(OctreeElement* element) { AACube elementCube = element->getAACube(); AACube modelCube = _newModel.getAACube(); return elementCube.contains(modelCube); } bool StoreModelOperator::PreRecursion(OctreeElement* element) { ModelTreeElement* modelTreeElement = static_cast(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 model, and this branch contains our old model // * We have not yet found the new model, and this branch contains our new model // // Note: it's often the case that the branch in question contains both the old model // and the new model. bool keepSearching = false; // assume we don't need to search any more // If we haven't yet found the old model, and this subTreeContains our old // model, then we need to keep searching. if (!_foundOld && subTreeContainsOldModel(element)) { // If this is the element we're looking for, then ask it to remove the old model // and we can stop searching. if (modelTreeElement == _containingElement) { // If the containgElement IS NOT the best fit for the new model properties // then we need to remove it, and the updateModel below will store it in the // correct element. if (!_containingElement->bestFitModelBounds(_newModel)) { modelTreeElement->removeModelWithModelItemID(_newModel.getModelItemID()); // If we haven't yet found the new location, then we need to // make sure to remove our model to element map, because for // now we're not in that map if (!_foundNew) { _tree->setContainingElement(_newModel.getModelItemID(), NULL); } } _foundOld = true; } else { // if this isn't the element we're looking for, then keep searching keepSearching = true; } } // If we haven't yet found the new model, and this subTreeContains our new // model, then we need to keep searching. if (!_foundNew && subTreeContainsNewModel(element)) { // Note: updateModel() will only operate on correctly found models and/or add them // to the element if they SHOULD be stored there. if (modelTreeElement->updateModel(_newModel)) { //qDebug() << "StoreModelOperator::PreRecursion()... model was updated!"; _foundNew = true; // NOTE: don't change the keepSearching here, if it came in here // false then we stay false, if it came in here true, then it // means we're still searching for our old model and this branch // contains our old model. In which case we want to keep searching. } else { keepSearching = true; } } return keepSearching; // if we haven't yet found it, keep looking } bool StoreModelOperator::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 model and one for the new model. bool keepSearching = !_foundOld || !_foundNew; // As we unwind, if we're in either of these two paths, we mark our element // as dirty. if ((_foundOld && subTreeContainsOldModel(element)) || (_foundNew && subTreeContainsNewModel(element))) { element->markWithChangedTime(); } return keepSearching; // if we haven't yet found it, keep looking } OctreeElement* StoreModelOperator::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 model location. // Check to see if if (!_foundNew) { int indexOfChildContainingNewModel = element->getMyChildContaining(_newModel.getAACube()); if (childIndex == indexOfChildContainingNewModel) { return element->addChildAtIndex(childIndex); } } return NULL; } void ModelTree::storeModel(const ModelItem& model, const SharedNodePointer& senderNode) { // NOTE: callers must lock the tree before using this method // First, look for the existing model in the tree.. StoreModelOperator theOperator(this, model); recurseTreeWithOperator(&theOperator); _isDirty = true; bool wantDebug = false; if (wantDebug) { ModelTreeElement* containingElement = getContainingElement(model.getModelItemID()); qDebug() << "ModelTree::storeModel().... after store... containingElement=" << containingElement; } } void ModelTree::updateModel(const ModelItemID& modelID, const ModelItemProperties& properties) { ModelItem updateItem(modelID); bool wantDebug = false; if (wantDebug) { qDebug() << "ModelTree::updateModel(modelID, properties) line:" << __LINE__ << "updateItem:"; updateItem.debugDump(); } // since the properties might not be complete, they may only contain some values, // we need to first see if we already have the model in our tree, and make a copy of // its existing properties first ModelTreeElement* containingElement = getContainingElement(modelID); if (wantDebug) { qDebug() << "ModelTree::updateModel(modelID, properties) containingElement=" << containingElement; } if (containingElement) { const ModelItem* oldModel = containingElement->getModelWithModelItemID(modelID); if (oldModel) { ModelItemProperties oldProps = oldModel->getProperties(); if (wantDebug) { qDebug() << "ModelTree::updateModel(modelID, properties) ********** COPY PROPERTIES FROM oldModel=" << oldModel << "*******************"; qDebug() << "ModelTree::updateModel(modelID, properties) oldModel=" << oldModel; oldProps.debugDump(); qDebug() << "ModelTree::updateModel(modelID, properties) line:" << __LINE__ << "about to call updateItem.setProperties(oldProps);"; } updateItem.setProperties(oldProps, true); // force copy if (wantDebug) { qDebug() << "ModelTree::updateModel(modelID, properties) line:" << __LINE__ << "updateItem:"; updateItem.debugDump(); } } else { if (wantDebug) { qDebug() << "ModelTree::updateModel(modelID, properties) WAIT WHAT!!! COULDN'T FIND oldModel=" << oldModel; } } } updateItem.setProperties(properties); if (wantDebug) { qDebug() << "ModelTree::updateModel(modelID, properties) line:" << __LINE__ << "updateItem:"; updateItem.debugDump(); } storeModel(updateItem); } void ModelTree::addModel(const ModelItemID& modelID, const ModelItemProperties& properties) { ModelItem updateItem(modelID, properties); storeModel(updateItem); } class ModelToDeleteDetails { public: const ModelItem* model; AACube cube; ModelTreeElement* containingElement; }; inline uint qHash(const ModelToDeleteDetails& a, uint seed) { return qHash(a.model->getModelItemID(), seed); } inline bool operator==(const ModelToDeleteDetails& a, const ModelToDeleteDetails& b) { return a.model->getModelItemID() == b.model->getModelItemID(); } class DeleteModelOperator : public RecurseOctreeOperator { public: DeleteModelOperator(ModelTree* tree); DeleteModelOperator(ModelTree* tree, const ModelItemID& searchModelID); void modelToDelete(const ModelItemID& searchModelID); virtual bool PreRecursion(OctreeElement* element); virtual bool PostRecursion(OctreeElement* element); private: ModelTree* _tree; QSet _modelsToDelete; quint64 _changeTime; int _foundCount; int _lookingCount; bool subTreeContainsSomeModelsToDelete(OctreeElement* element); }; DeleteModelOperator::DeleteModelOperator(ModelTree* tree, const ModelItemID& searchModelID) : _tree(tree), _changeTime(usecTimestampNow()), _foundCount(0), _lookingCount(0) { modelToDelete(searchModelID); } DeleteModelOperator::DeleteModelOperator(ModelTree* tree) : _tree(tree), _changeTime(usecTimestampNow()), _foundCount(0), _lookingCount(0) { } void DeleteModelOperator::modelToDelete(const ModelItemID& searchModelID) { // check our tree, to determine if this model is known ModelToDeleteDetails details; details.containingElement = _tree->getContainingElement(searchModelID); if (details.containingElement) { details.model = details.containingElement->getModelWithModelItemID(searchModelID); if (!details.model) { //assert(false); qDebug() << "that's UNEXPECTED, we got a _containingElement, but couldn't find the oldModel!"; } else { details.cube = details.model->getAACube(); _modelsToDelete << details; _lookingCount++; } } } // does this model tree element contain the old model bool DeleteModelOperator::subTreeContainsSomeModelsToDelete(OctreeElement* element) { bool containsModel = false; // If we don't have an old model, then we don't contain the model, otherwise // check the bounds if (_modelsToDelete.size() > 0) { AACube elementCube = element->getAACube(); foreach(const ModelToDeleteDetails& details, _modelsToDelete) { if (elementCube.contains(details.cube)) { containsModel = true; break; // if it contains at least one, we're good to go } } } return containsModel; } bool DeleteModelOperator::PreRecursion(OctreeElement* element) { ModelTreeElement* modelTreeElement = static_cast(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 model, and this branch contains our old model // * We have not yet found the new model, and this branch contains our new model // // Note: it's often the case that the branch in question contains both the old model // and the new model. bool keepSearching = false; // assume we don't need to search any more // If we haven't yet found all the models, and this sub tree contains at least one of our // models, then we need to keep searching. if ((_foundCount < _lookingCount) && subTreeContainsSomeModelsToDelete(element)) { // check against each of our search models foreach(const ModelToDeleteDetails& details, _modelsToDelete) { // If this is the element we're looking for, then ask it to remove the old model // and we can stop searching. if (modelTreeElement == details.containingElement) { // This is a good place to delete it!!! ModelItemID modelItemID = details.model->getModelItemID(); modelTreeElement->removeModelWithModelItemID(modelItemID); _tree->setContainingElement(modelItemID, NULL); _foundCount++; } } // if we haven't found all of our search for models, then keep looking keepSearching = (_foundCount < _lookingCount); } return keepSearching; // if we haven't yet found it, keep looking } bool DeleteModelOperator::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 model and one for the new model. bool keepSearching = (_foundCount < _lookingCount); // As we unwind, if we're in either of these two paths, we mark our element // as dirty. if ((subTreeContainsSomeModelsToDelete(element))) { element->markWithChangedTime(); } return keepSearching; // if we haven't yet found it, keep looking } void ModelTree::deleteModel(const ModelItemID& modelID) { // NOTE: callers must lock the tree before using this method // First, look for the existing model in the tree.. DeleteModelOperator theOperator(this, modelID); recurseTreeWithOperator(&theOperator); _isDirty = true; bool wantDebug = false; if (wantDebug) { ModelTreeElement* containingElement = getContainingElement(modelID); qDebug() << "ModelTree::storeModel().... after store... containingElement=" << containingElement; } } void ModelTree::deleteModels(QSet modelIDs) { // NOTE: callers must lock the tree before using this method DeleteModelOperator theOperator(this); foreach(const ModelItemID& modelID, modelIDs) { // First, look for the existing model in the tree.. theOperator.modelToDelete(modelID); } recurseTreeWithOperator(&theOperator); _isDirty = true; bool wantDebug = false; if (wantDebug) { foreach(const ModelItemID& modelID, modelIDs) { ModelTreeElement* containingElement = getContainingElement(modelID); qDebug() << "ModelTree::storeModel().... after store... containingElement=" << containingElement; } } } // scans the tree and handles mapping locally created models to know IDs. // in the event that this tree is also viewing the scene, then we need to also // search the tree to make sure we don't have a duplicate model from the viewing // operation. bool ModelTree::findAndUpdateModelItemIDOperation(OctreeElement* element, void* extraData) { bool keepSearching = true; FindAndUpdateModelItemIDArgs* args = static_cast(extraData); ModelTreeElement* modelTreeElement = static_cast(element); // Note: updateModelItemID() will only operate on correctly found models modelTreeElement->updateModelItemID(args); // if we've found and replaced both the creatorTokenID and the viewedModel, then we // can stop looking, otherwise we will keep looking if (args->creatorTokenFound && args->viewedModelFound) { keepSearching = false; } return keepSearching; } void ModelTree::handleAddModelResponse(const QByteArray& packet) { const bool wantDebug = false; if (wantDebug) { qDebug() << "ModelTree::handleAddModelResponse()..."; } int numBytesPacketHeader = numBytesForPacketHeader(packet); const unsigned char* dataAt = reinterpret_cast(packet.data()) + numBytesPacketHeader; uint32_t creatorTokenID; memcpy(&creatorTokenID, dataAt, sizeof(creatorTokenID)); dataAt += sizeof(creatorTokenID); uint32_t modelID; memcpy(&modelID, dataAt, sizeof(modelID)); dataAt += sizeof(modelID); if (wantDebug) { qDebug() << " creatorTokenID=" << creatorTokenID; qDebug() << " modelID=" << modelID; } // update models in our tree bool assumeModelFound = !getIsViewing(); // if we're not a viewing tree, then we don't have to find the actual model FindAndUpdateModelItemIDArgs args = { modelID, creatorTokenID, false, assumeModelFound, getIsViewing() }; if (wantDebug) { qDebug() << "looking for creatorTokenID=" << creatorTokenID << " modelID=" << modelID << " getIsViewing()=" << getIsViewing(); } lockForWrite(); // TODO: Switch this to use list of known model IDs.... recurseTreeWithOperation(findAndUpdateModelItemIDOperation, &args); unlock(); } class FindNearPointArgs { public: glm::vec3 position; float targetRadius; bool found; const ModelItem* closestModel; float closestModelDistance; }; bool ModelTree::findNearPointOperation(OctreeElement* element, void* extraData) { FindNearPointArgs* args = static_cast(extraData); ModelTreeElement* modelTreeElement = static_cast(element); glm::vec3 penetration; bool sphereIntersection = modelTreeElement->getAACube().findSpherePenetration(args->position, args->targetRadius, penetration); // If this modelTreeElement contains the point, then search it... if (sphereIntersection) { const ModelItem* thisClosestModel = modelTreeElement->getClosestModel(args->position); // we may have gotten NULL back, meaning no model was available if (thisClosestModel) { glm::vec3 modelPosition = thisClosestModel->getPosition(); float distanceFromPointToModel = glm::distance(modelPosition, args->position); // If we're within our target radius if (distanceFromPointToModel <= args->targetRadius) { // we are closer than anything else we've found if (distanceFromPointToModel < args->closestModelDistance) { args->closestModel = thisClosestModel; args->closestModelDistance = distanceFromPointToModel; args->found = true; } } } // we should be able to optimize this... return true; // keep searching in case children have closer models } // if this element doesn't contain the point, then none of it's children can contain the point, so stop searching return false; } const ModelItem* ModelTree::findClosestModel(glm::vec3 position, float targetRadius) { FindNearPointArgs args = { position, targetRadius, false, NULL, FLT_MAX }; lockForRead(); // NOTE: This should use recursion, since this is a spatial operation recurseTreeWithOperation(findNearPointOperation, &args); unlock(); return args.closestModel; } class FindAllNearPointArgs { public: glm::vec3 position; float targetRadius; QVector models; }; bool ModelTree::findInSphereOperation(OctreeElement* element, void* extraData) { FindAllNearPointArgs* args = static_cast(extraData); glm::vec3 penetration; bool sphereIntersection = element->getAACube().findSpherePenetration(args->position, args->targetRadius, penetration); // If this element contains the point, then search it... if (sphereIntersection) { ModelTreeElement* modelTreeElement = static_cast(element); modelTreeElement->getModels(args->position, args->targetRadius, args->models); return true; // keep searching in case children have closer models } // if this element doesn't contain the point, then none of it's children can contain the point, so stop searching return false; } void ModelTree::findModels(const glm::vec3& center, float radius, QVector& foundModels) { FindAllNearPointArgs args = { center, radius }; lockForRead(); // NOTE: This should use recursion, since this is a spatial operation recurseTreeWithOperation(findInSphereOperation, &args); unlock(); // swap the two lists of model pointers instead of copy foundModels.swap(args.models); } class FindModelsInCubeArgs { public: FindModelsInCubeArgs(const AACube& cube) : _cube(cube), _foundModels() { } AACube _cube; QVector _foundModels; }; bool ModelTree::findInCubeOperation(OctreeElement* element, void* extraData) { FindModelsInCubeArgs* args = static_cast< FindModelsInCubeArgs*>(extraData); const AACube& elementCube = element->getAACube(); if (elementCube.touches(args->_cube)) { ModelTreeElement* modelTreeElement = static_cast(element); modelTreeElement->getModels(args->_cube, args->_foundModels); return true; } return false; } void ModelTree::findModels(const AACube& cube, QVector foundModels) { FindModelsInCubeArgs args(cube); lockForRead(); // NOTE: This should use recursion, since this is a spatial operation recurseTreeWithOperation(findInCubeOperation, &args); unlock(); // swap the two lists of model pointers instead of copy foundModels.swap(args._foundModels); } const ModelItem* ModelTree::findModelByID(uint32_t id, bool alreadyLocked) const { ModelItemID modelID(id); bool wantDebug = false; if (wantDebug) { qDebug() << "ModelTree::findModelByID()..."; qDebug() << " id=" << id; qDebug() << " modelID=" << modelID; qDebug() << "_modelToElementMap=" << _modelToElementMap; } return findModelByModelItemID(modelID); } const ModelItem* ModelTree::findModelByModelItemID(const ModelItemID& modelID) const { const ModelItem* foundModel = NULL; ModelTreeElement* containingElement = getContainingElement(modelID); if (containingElement) { foundModel = containingElement->getModelWithModelItemID(modelID); } return foundModel; } int ModelTree::processEditPacketData(PacketType packetType, const unsigned char* packetData, int packetLength, const unsigned char* editData, int maxLength, const SharedNodePointer& senderNode) { int processedBytes = 0; // we handle these types of "edit" packets switch (packetType) { case PacketTypeModelAddOrEdit: { bool isValid; ModelItem newModel = ModelItem::fromEditPacket(editData, maxLength, processedBytes, this, isValid); if (isValid) { storeModel(newModel, senderNode); if (newModel.isNewlyCreated()) { notifyNewlyCreatedModel(newModel, senderNode); } } } break; default: processedBytes = 0; break; } return processedBytes; } void ModelTree::notifyNewlyCreatedModel(const ModelItem& newModel, const SharedNodePointer& senderNode) { _newlyCreatedHooksLock.lockForRead(); for (size_t i = 0; i < _newlyCreatedHooks.size(); i++) { _newlyCreatedHooks[i]->modelCreated(newModel, senderNode); } _newlyCreatedHooksLock.unlock(); } void ModelTree::addNewlyCreatedHook(NewlyCreatedModelHook* hook) { _newlyCreatedHooksLock.lockForWrite(); _newlyCreatedHooks.push_back(hook); _newlyCreatedHooksLock.unlock(); } void ModelTree::removeNewlyCreatedHook(NewlyCreatedModelHook* hook) { _newlyCreatedHooksLock.lockForWrite(); for (size_t i = 0; i < _newlyCreatedHooks.size(); i++) { if (_newlyCreatedHooks[i] == hook) { _newlyCreatedHooks.erase(_newlyCreatedHooks.begin() + i); break; } } _newlyCreatedHooksLock.unlock(); } bool ModelTree::updateOperation(OctreeElement* element, void* extraData) { ModelTreeUpdateArgs* args = static_cast(extraData); ModelTreeElement* modelTreeElement = static_cast(element); modelTreeElement->update(*args); return true; } bool ModelTree::pruneOperation(OctreeElement* element, void* extraData) { ModelTreeElement* modelTreeElement = static_cast(element); for (int i = 0; i < NUMBER_OF_CHILDREN; i++) { ModelTreeElement* childAt = modelTreeElement->getChildAtIndex(i); if (childAt && childAt->isLeaf() && !childAt->hasModels()) { modelTreeElement->deleteChildAtIndex(i); } } return true; } void ModelTree::update() { lockForWrite(); _isDirty = true; // TODO: could we manage this by iterating the known models map/hash? Would that be faster? ModelTreeUpdateArgs args; recurseTreeWithOperation(updateOperation, &args); // now add back any of the particles that moved elements.... int movingModels = args._movingModels.size(); for (int i = 0; i < movingModels; i++) { bool shouldDie = args._movingModels[i].getShouldDie(); // if the particle is still inside our total bounds, then re-add it AACube treeBounds = getRoot()->getAACube(); if (!shouldDie && treeBounds.contains(args._movingModels[i].getPosition())) { storeModel(args._movingModels[i]); } else { uint32_t modelItemID = args._movingModels[i].getID(); quint64 deletedAt = usecTimestampNow(); _recentlyDeletedModelsLock.lockForWrite(); _recentlyDeletedModelItemIDs.insert(deletedAt, modelItemID); _recentlyDeletedModelsLock.unlock(); } } // prune the tree... recurseTreeWithOperation(pruneOperation, NULL); unlock(); } bool ModelTree::hasModelsDeletedSince(quint64 sinceTime) { // we can probably leverage the ordered nature of QMultiMap to do this quickly... bool hasSomethingNewer = false; _recentlyDeletedModelsLock.lockForRead(); QMultiMap::const_iterator iterator = _recentlyDeletedModelItemIDs.constBegin(); while (iterator != _recentlyDeletedModelItemIDs.constEnd()) { //qDebug() << "considering... time/key:" << iterator.key(); if (iterator.key() > sinceTime) { //qDebug() << "YES newer... time/key:" << iterator.key(); hasSomethingNewer = true; } ++iterator; } _recentlyDeletedModelsLock.unlock(); return hasSomethingNewer; } // sinceTime is an in/out parameter - it will be side effected with the last time sent out bool ModelTree::encodeModelsDeletedSince(OCTREE_PACKET_SEQUENCE sequenceNumber, quint64& sinceTime, unsigned char* outputBuffer, size_t maxLength, size_t& outputLength) { bool hasMoreToSend = true; unsigned char* copyAt = outputBuffer; size_t numBytesPacketHeader = populatePacketHeader(reinterpret_cast(outputBuffer), PacketTypeModelErase); copyAt += numBytesPacketHeader; outputLength = numBytesPacketHeader; // pack in flags OCTREE_PACKET_FLAGS flags = 0; OCTREE_PACKET_FLAGS* flagsAt = (OCTREE_PACKET_FLAGS*)copyAt; *flagsAt = flags; copyAt += sizeof(OCTREE_PACKET_FLAGS); outputLength += sizeof(OCTREE_PACKET_FLAGS); // pack in sequence number OCTREE_PACKET_SEQUENCE* sequenceAt = (OCTREE_PACKET_SEQUENCE*)copyAt; *sequenceAt = sequenceNumber; copyAt += sizeof(OCTREE_PACKET_SEQUENCE); outputLength += sizeof(OCTREE_PACKET_SEQUENCE); // pack in timestamp OCTREE_PACKET_SENT_TIME now = usecTimestampNow(); OCTREE_PACKET_SENT_TIME* timeAt = (OCTREE_PACKET_SENT_TIME*)copyAt; *timeAt = now; copyAt += sizeof(OCTREE_PACKET_SENT_TIME); outputLength += sizeof(OCTREE_PACKET_SENT_TIME); uint16_t numberOfIds = 0; // placeholder for now unsigned char* numberOfIDsAt = copyAt; memcpy(copyAt, &numberOfIds, sizeof(numberOfIds)); copyAt += sizeof(numberOfIds); outputLength += sizeof(numberOfIds); // we keep a multi map of model IDs to timestamps, we only want to include the model IDs that have been // deleted since we last sent to this node _recentlyDeletedModelsLock.lockForRead(); QMultiMap::const_iterator iterator = _recentlyDeletedModelItemIDs.constBegin(); while (iterator != _recentlyDeletedModelItemIDs.constEnd()) { QList values = _recentlyDeletedModelItemIDs.values(iterator.key()); for (int valueItem = 0; valueItem < values.size(); ++valueItem) { // if the timestamp is more recent then out last sent time, include it if (iterator.key() > sinceTime) { uint32_t modelID = values.at(valueItem); memcpy(copyAt, &modelID, sizeof(modelID)); copyAt += sizeof(modelID); outputLength += sizeof(modelID); numberOfIds++; // check to make sure we have room for one more id... if (outputLength + sizeof(uint32_t) > maxLength) { break; } } } // check to make sure we have room for one more id... if (outputLength + sizeof(uint32_t) > maxLength) { // let our caller know how far we got sinceTime = iterator.key(); break; } ++iterator; } // if we got to the end, then we're done sending if (iterator == _recentlyDeletedModelItemIDs.constEnd()) { hasMoreToSend = false; } _recentlyDeletedModelsLock.unlock(); // replace the correct count for ids included memcpy(numberOfIDsAt, &numberOfIds, sizeof(numberOfIds)); return hasMoreToSend; } // called by the server when it knows all nodes have been sent deleted packets void ModelTree::forgetModelsDeletedBefore(quint64 sinceTime) { //qDebug() << "forgetModelsDeletedBefore()"; QSet keysToRemove; _recentlyDeletedModelsLock.lockForWrite(); QMultiMap::iterator iterator = _recentlyDeletedModelItemIDs.begin(); // First find all the keys in the map that are older and need to be deleted while (iterator != _recentlyDeletedModelItemIDs.end()) { if (iterator.key() <= sinceTime) { keysToRemove << iterator.key(); } ++iterator; } // Now run through the keysToRemove and remove them foreach (quint64 value, keysToRemove) { //qDebug() << "removing the key, _recentlyDeletedModelItemIDs.remove(value); time/key:" << value; _recentlyDeletedModelItemIDs.remove(value); } _recentlyDeletedModelsLock.unlock(); } void ModelTree::processEraseMessage(const QByteArray& dataByteArray, const SharedNodePointer& sourceNode) { const unsigned char* packetData = (const unsigned char*)dataByteArray.constData(); const unsigned char* dataAt = packetData; size_t packetLength = dataByteArray.size(); size_t numBytesPacketHeader = numBytesForPacketHeader(dataByteArray); size_t processedBytes = numBytesPacketHeader; dataAt += numBytesPacketHeader; dataAt += sizeof(OCTREE_PACKET_FLAGS); dataAt += sizeof(OCTREE_PACKET_SEQUENCE); dataAt += sizeof(OCTREE_PACKET_SENT_TIME); uint16_t numberOfIds = 0; // placeholder for now memcpy(&numberOfIds, dataAt, sizeof(numberOfIds)); dataAt += sizeof(numberOfIds); processedBytes += sizeof(numberOfIds); if (numberOfIds > 0) { QSet modelItemIDsToDelete; for (size_t i = 0; i < numberOfIds; i++) { if (processedBytes + sizeof(uint32_t) > packetLength) { break; // bail to prevent buffer overflow } uint32_t modelID = 0; // placeholder for now memcpy(&modelID, dataAt, sizeof(modelID)); dataAt += sizeof(modelID); processedBytes += sizeof(modelID); ModelItemID modelItemID(modelID); modelItemIDsToDelete << modelItemID; } deleteModels(modelItemIDsToDelete); } } ModelTreeElement* ModelTree::getContainingElement(const ModelItemID& modelItemID) const { //qDebug() << "_modelToElementMap=" << _modelToElementMap; // TODO: do we need to make this thread safe? Or is it acceptable as is if (_modelToElementMap.contains(modelItemID)) { return _modelToElementMap.value(modelItemID); } return NULL; } void ModelTree::setContainingElement(const ModelItemID& modelItemID, ModelTreeElement* element) { // TODO: do we need to make this thread safe? Or is it acceptable as is if (element) { _modelToElementMap[modelItemID] = element; } else { _modelToElementMap.remove(modelItemID); } //qDebug() << "setContainingElement() modelItemID=" << modelItemID << "element=" << element; //qDebug() << "AFTER _modelToElementMap=" << _modelToElementMap; } void ModelTree::debugDumpMap() { QHashIterator i(_modelToElementMap); while (i.hasNext()) { i.next(); qDebug() << i.key() << ": " << i.value(); } }