mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-05-11 10:19:23 +02:00
362 lines
14 KiB
C++
362 lines
14 KiB
C++
//
|
|
// ModelTreeElement.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 <GeometryUtil.h>
|
|
|
|
#include "ModelTree.h"
|
|
#include "ModelTreeElement.h"
|
|
|
|
ModelTreeElement::ModelTreeElement(unsigned char* octalCode) : OctreeElement(), _modelItems(NULL) {
|
|
init(octalCode);
|
|
};
|
|
|
|
ModelTreeElement::~ModelTreeElement() {
|
|
_voxelMemoryUsage -= sizeof(ModelTreeElement);
|
|
delete _modelItems;
|
|
_modelItems = NULL;
|
|
}
|
|
|
|
// This will be called primarily on addChildAt(), which means we're adding a child of our
|
|
// own type to our own tree. This means we should initialize that child with any tree and type
|
|
// specific settings that our children must have. One example is out VoxelSystem, which
|
|
// we know must match ours.
|
|
OctreeElement* ModelTreeElement::createNewElement(unsigned char* octalCode) {
|
|
ModelTreeElement* newChild = new ModelTreeElement(octalCode);
|
|
newChild->setTree(_myTree);
|
|
return newChild;
|
|
}
|
|
|
|
void ModelTreeElement::init(unsigned char* octalCode) {
|
|
OctreeElement::init(octalCode);
|
|
_modelItems = new QList<ModelItem>;
|
|
_voxelMemoryUsage += sizeof(ModelTreeElement);
|
|
}
|
|
|
|
ModelTreeElement* ModelTreeElement::addChildAtIndex(int index) {
|
|
ModelTreeElement* newElement = (ModelTreeElement*)OctreeElement::addChildAtIndex(index);
|
|
newElement->setTree(_myTree);
|
|
return newElement;
|
|
}
|
|
|
|
|
|
bool ModelTreeElement::appendElementData(OctreePacketData* packetData, EncodeBitstreamParams& params) const {
|
|
bool success = true; // assume the best...
|
|
|
|
// write our models out... first determine which of the models are in view based on our params
|
|
uint16_t numberOfModels = 0;
|
|
QVector<uint16_t> indexesOfModelsToInclude;
|
|
|
|
for (uint16_t i = 0; i < _modelItems->size(); i++) {
|
|
if (params.viewFrustum) {
|
|
const ModelItem& model = (*_modelItems)[i];
|
|
AABox modelBox = model.getAABox();
|
|
modelBox.scale(TREE_SCALE);
|
|
if (params.viewFrustum->boxInFrustum(modelBox) != ViewFrustum::OUTSIDE) {
|
|
indexesOfModelsToInclude << i;
|
|
numberOfModels++;
|
|
}
|
|
} else {
|
|
indexesOfModelsToInclude << i;
|
|
numberOfModels++;
|
|
}
|
|
}
|
|
|
|
success = packetData->appendValue(numberOfModels);
|
|
|
|
if (success) {
|
|
foreach (uint16_t i, indexesOfModelsToInclude) {
|
|
const ModelItem& model = (*_modelItems)[i];
|
|
success = model.appendModelData(packetData);
|
|
if (!success) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
bool ModelTreeElement::containsModelBounds(const ModelItem& model) const {
|
|
return _box.contains(model.getMinimumPoint()) && _box.contains(model.getMaximumPoint());
|
|
}
|
|
|
|
bool ModelTreeElement::bestFitModelBounds(const ModelItem& model) const {
|
|
if (_box.contains(model.getMinimumPoint()) && _box.contains(model.getMaximumPoint())) {
|
|
int childForMinimumPoint = getMyChildContainingPoint(model.getMinimumPoint());
|
|
int childForMaximumPoint = getMyChildContainingPoint(model.getMaximumPoint());
|
|
|
|
// If I contain both the minimum and maximum point, but two different children of mine
|
|
// contain those points, then I am the best fit for that model
|
|
if (childForMinimumPoint != childForMaximumPoint) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ModelTreeElement::update(ModelTreeUpdateArgs& args) {
|
|
// update our contained models
|
|
QList<ModelItem>::iterator modelItr = _modelItems->begin();
|
|
while(modelItr != _modelItems->end()) {
|
|
ModelItem& model = (*modelItr);
|
|
model.update(_lastChanged);
|
|
|
|
// If the model wants to die, or if it's left our bounding box, then move it
|
|
// into the arguments moving models. These will be added back or deleted completely
|
|
if (model.getShouldDie() || !bestFitModelBounds(model)) {
|
|
args._movingModels.push_back(model);
|
|
|
|
// erase this model
|
|
modelItr = _modelItems->erase(modelItr);
|
|
|
|
// this element has changed so mark it...
|
|
markWithChangedTime();
|
|
} else {
|
|
++modelItr;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ModelTreeElement::findSpherePenetration(const glm::vec3& center, float radius,
|
|
glm::vec3& penetration, void** penetratedObject) const {
|
|
QList<ModelItem>::iterator modelItr = _modelItems->begin();
|
|
QList<ModelItem>::const_iterator modelEnd = _modelItems->end();
|
|
while(modelItr != modelEnd) {
|
|
ModelItem& model = (*modelItr);
|
|
glm::vec3 modelCenter = model.getPosition();
|
|
float modelRadius = model.getRadius();
|
|
|
|
// don't penetrate yourself
|
|
if (modelCenter == center && modelRadius == radius) {
|
|
return false;
|
|
}
|
|
|
|
if (findSphereSpherePenetration(center, radius, modelCenter, modelRadius, penetration)) {
|
|
// return true on first valid model penetration
|
|
*penetratedObject = (void*)(&model);
|
|
return true;
|
|
}
|
|
++modelItr;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ModelTreeElement::updateModel(const ModelItem& model) {
|
|
// NOTE: this method must first lookup the model by ID, hence it is O(N)
|
|
// and "model is not found" is worst-case (full N) but maybe we don't care?
|
|
// (guaranteed that num models per elemen is small?)
|
|
const bool wantDebug = false;
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
ModelItem& thisModel = (*_modelItems)[i];
|
|
if (thisModel.getID() == model.getID()) {
|
|
int difference = thisModel.getLastUpdated() - model.getLastUpdated();
|
|
bool changedOnServer = thisModel.getLastEdited() < model.getLastEdited();
|
|
bool localOlder = thisModel.getLastUpdated() < model.getLastUpdated();
|
|
if (changedOnServer || localOlder) {
|
|
if (wantDebug) {
|
|
qDebug("local model [id:%d] %s and %s than server model by %d, model.isNewlyCreated()=%s",
|
|
model.getID(), (changedOnServer ? "CHANGED" : "same"),
|
|
(localOlder ? "OLDER" : "NEWER"),
|
|
difference, debug::valueOf(model.isNewlyCreated()) );
|
|
}
|
|
|
|
thisModel.copyChangedProperties(model);
|
|
markWithChangedTime();
|
|
} else {
|
|
if (wantDebug) {
|
|
qDebug(">>> IGNORING SERVER!!! Would've caused jutter! <<< "
|
|
"local model [id:%d] %s and %s than server model by %d, model.isNewlyCreated()=%s",
|
|
model.getID(), (changedOnServer ? "CHANGED" : "same"),
|
|
(localOlder ? "OLDER" : "NEWER"),
|
|
difference, debug::valueOf(model.isNewlyCreated()) );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ModelTreeElement::updateModel(const ModelItemID& modelID, const ModelItemProperties& properties) {
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
// note: unlike storeModel() which is called from inbound packets, this is only called by local editors
|
|
// and therefore we can be confident that this change is higher priority and should be honored
|
|
ModelItem& thisModel = (*_modelItems)[i];
|
|
|
|
bool found = false;
|
|
if (modelID.isKnownID) {
|
|
found = thisModel.getID() == modelID.id;
|
|
} else {
|
|
found = thisModel.getCreatorTokenID() == modelID.creatorTokenID;
|
|
}
|
|
if (found) {
|
|
thisModel.setProperties(properties);
|
|
markWithChangedTime(); // mark our element as changed..
|
|
const bool wantDebug = false;
|
|
if (wantDebug) {
|
|
uint64_t now = usecTimestampNow();
|
|
int elapsed = now - thisModel.getLastEdited();
|
|
|
|
qDebug() << "ModelTreeElement::updateModel() AFTER update... edited AGO=" << elapsed <<
|
|
"now=" << now << " thisModel.getLastEdited()=" << thisModel.getLastEdited();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ModelTreeElement::updateModelItemID(FindAndUpdateModelItemIDArgs* args) {
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
ModelItem& thisModel = (*_modelItems)[i];
|
|
|
|
if (!args->creatorTokenFound) {
|
|
// first, we're looking for matching creatorTokenIDs, if we find that, then we fix it to know the actual ID
|
|
if (thisModel.getCreatorTokenID() == args->creatorTokenID) {
|
|
thisModel.setID(args->modelID);
|
|
args->creatorTokenFound = true;
|
|
}
|
|
}
|
|
|
|
// if we're in an isViewing tree, we also need to look for an kill any viewed models
|
|
if (!args->viewedModelFound && args->isViewing) {
|
|
if (thisModel.getCreatorTokenID() == UNKNOWN_MODEL_TOKEN && thisModel.getID() == args->modelID) {
|
|
_modelItems->removeAt(i); // remove the model at this index
|
|
numberOfModels--; // this means we have 1 fewer model in this list
|
|
i--; // and we actually want to back up i as well.
|
|
args->viewedModelFound = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
const ModelItem* ModelTreeElement::getClosestModel(glm::vec3 position) const {
|
|
const ModelItem* closestModel = NULL;
|
|
float closestModelDistance = FLT_MAX;
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
float distanceToModel = glm::distance(position, (*_modelItems)[i].getPosition());
|
|
if (distanceToModel < closestModelDistance) {
|
|
closestModel = &(*_modelItems)[i];
|
|
}
|
|
}
|
|
return closestModel;
|
|
}
|
|
|
|
void ModelTreeElement::getModels(const glm::vec3& searchPosition, float searchRadius, QVector<const ModelItem*>& foundModels) const {
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
const ModelItem* model = &(*_modelItems)[i];
|
|
float distance = glm::length(model->getPosition() - searchPosition);
|
|
if (distance < searchRadius + model->getRadius()) {
|
|
foundModels.push_back(model);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModelTreeElement::getModelsForUpdate(const AABox& box, QVector<ModelItem*>& foundModels) {
|
|
QList<ModelItem>::iterator modelItr = _modelItems->begin();
|
|
QList<ModelItem>::iterator modelEnd = _modelItems->end();
|
|
AABox modelBox;
|
|
while(modelItr != modelEnd) {
|
|
ModelItem* model = &(*modelItr);
|
|
float radius = model->getRadius();
|
|
// NOTE: we actually do box-box collision queries here, which is sloppy but good enough for now
|
|
// TODO: decide whether to replace modelBox-box query with sphere-box (requires a square root
|
|
// but will be slightly more accurate).
|
|
modelBox.setBox(model->getPosition() - glm::vec3(radius), 2.f * radius);
|
|
if (modelBox.touches(_box)) {
|
|
foundModels.push_back(model);
|
|
}
|
|
++modelItr;
|
|
}
|
|
}
|
|
|
|
const ModelItem* ModelTreeElement::getModelWithID(uint32_t id) const {
|
|
// NOTE: this lookup is O(N) but maybe we don't care? (guaranteed that num models per elemen is small?)
|
|
const ModelItem* foundModel = NULL;
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
if ((*_modelItems)[i].getID() == id) {
|
|
foundModel = &(*_modelItems)[i];
|
|
break;
|
|
}
|
|
}
|
|
return foundModel;
|
|
}
|
|
|
|
bool ModelTreeElement::removeModelWithID(uint32_t id) {
|
|
bool foundModel = false;
|
|
uint16_t numberOfModels = _modelItems->size();
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
if ((*_modelItems)[i].getID() == id) {
|
|
foundModel = true;
|
|
_modelItems->removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
return foundModel;
|
|
}
|
|
|
|
int ModelTreeElement::readElementDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
|
|
ReadBitstreamToTreeParams& args) {
|
|
|
|
const unsigned char* dataAt = data;
|
|
int bytesRead = 0;
|
|
uint16_t numberOfModels = 0;
|
|
int expectedBytesPerModel = ModelItem::expectedBytes();
|
|
|
|
if (bytesLeftToRead >= (int)sizeof(numberOfModels)) {
|
|
// read our models in....
|
|
numberOfModels = *(uint16_t*)dataAt;
|
|
dataAt += sizeof(numberOfModels);
|
|
bytesLeftToRead -= (int)sizeof(numberOfModels);
|
|
bytesRead += sizeof(numberOfModels);
|
|
|
|
if (bytesLeftToRead >= (int)(numberOfModels * expectedBytesPerModel)) {
|
|
for (uint16_t i = 0; i < numberOfModels; i++) {
|
|
ModelItem tempModel;
|
|
int bytesForThisModel = tempModel.readModelDataFromBuffer(dataAt, bytesLeftToRead, args);
|
|
_myTree->storeModel(tempModel);
|
|
dataAt += bytesForThisModel;
|
|
bytesLeftToRead -= bytesForThisModel;
|
|
bytesRead += bytesForThisModel;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bytesRead;
|
|
}
|
|
|
|
// will average a "common reduced LOD view" from the the child elements...
|
|
void ModelTreeElement::calculateAverageFromChildren() {
|
|
// nothing to do here yet...
|
|
}
|
|
|
|
// will detect if children are leaves AND collapsable into the parent node
|
|
// and in that case will collapse children and make this node
|
|
// a leaf, returns TRUE if all the leaves are collapsed into a
|
|
// single node
|
|
bool ModelTreeElement::collapseChildren() {
|
|
// nothing to do here yet...
|
|
return false;
|
|
}
|
|
|
|
|
|
void ModelTreeElement::storeModel(const ModelItem& model) {
|
|
_modelItems->push_back(model);
|
|
markWithChangedTime();
|
|
}
|
|
|