Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-10 13:07:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

small fixes and LOD cull children instead of parent

Browse source
This commit is contained in:
SamGondelman 2017-09-12 16:11:58 -07:00 committed by Andrew Meadows
parent 624d0c12a2
commit f2de03bc38
3 changed files with 58 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
assignment-client/src/entities/EntityTreeSendThread.cpp
View file

@ -121,7 +121,7 @@ void EntityTreeSendThread::traverseTreeAndSendContents(SharedNodePointer node, O
float renderAccuracy = calculateRenderAccuracy(_traversal.getCurrentView().getPosition(), float renderAccuracy = calculateRenderAccuracy(_traversal.getCurrentView().getPosition(),
cube, cube,
_traversal.getCurrentRootSizeScale(), _traversal.getCurrentRootSizeScale(),
lodLevelOffset); _traversal.getCurrentLODOffset());
// Only send entities if they are large enough to see // Only send entities if they are large enough to see
if (renderAccuracy > 0.0f) { if (renderAccuracy > 0.0f) {
@ -385,12 +385,12 @@ void EntityTreeSendThread::startNewTraversal(const ViewFrustum& view, EntityTree
_entitiesInQueue.insert(entity.get()); _entitiesInQueue.insert(entity.get());
} else { } else {
// If this entity was skipped last time because it was too small, we still need to send it // If this entity was skipped last time because it was too small, we still need to send it
float lastRenderAccuracy = calculateRenderAccuracy(_traversal.getCompletedView().getPosition(), renderAccuracy = calculateRenderAccuracy(_traversal.getCompletedView().getPosition(),
cube, cube,
_traversal.getCompletedRootSizeScale(), _traversal.getCompletedRootSizeScale(),
_traversal.getCompletedLODOffset()); _traversal.getCompletedLODOffset());
if (lastRenderAccuracy <= 0.0f) { if (renderAccuracy <= 0.0f) {
float priority = _conicalView.computePriority(cube); float priority = _conicalView.computePriority(cube);
_sendQueue.push(PrioritizedEntity(entity, priority)); _sendQueue.push(PrioritizedEntity(entity, priority));
_entitiesInQueue.insert(entity.get()); _entitiesInQueue.insert(entity.get());

103
libraries/entities/src/DiffTraversal.cpp
View file

@ -33,25 +33,22 @@ void DiffTraversal::Waypoint::getNextVisibleElementFirstTime(DiffTraversal::Visi
} else if (_nextIndex < NUMBER_OF_CHILDREN) { } else if (_nextIndex < NUMBER_OF_CHILDREN) {
EntityTreeElementPointer element = _weakElement.lock(); EntityTreeElementPointer element = _weakElement.lock();
if (element) { if (element) {
// No LOD truncation if we aren't using the view frustum while (_nextIndex < NUMBER_OF_CHILDREN) {
if (!view.usesViewFrustum) { EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex);
while (_nextIndex < NUMBER_OF_CHILDREN) { ++_nextIndex;
EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex); if (nextElement) {
++_nextIndex; if (!view.usesViewFrustum) {
if (nextElement) { // No LOD truncation if we aren't using the view frustum
next.element = nextElement; next.element = nextElement;
return; return;
} } else if (view.viewFrustum.cubeIntersectsKeyhole(nextElement->getAACube())) {
} // check for LOD truncation
} else { float renderAccuracy = calculateRenderAccuracy(view.viewFrustum.getPosition(),
// check for LOD truncation nextElement->getAACube(),
float visibleLimit = boundaryDistanceForRenderLevel(element->getLevel() + view.lodLevelOffset, view.rootSizeScale); view.rootSizeScale,
float distance2 = glm::distance2(view.viewFrustum.getPosition(), element->getAACube().calcCenter()); view.lodLevelOffset);
if (distance2 < visibleLimit * visibleLimit) {
while (_nextIndex < NUMBER_OF_CHILDREN) { if (renderAccuracy > 0.0f) {
EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex);
++_nextIndex;
if (nextElement && view.viewFrustum.cubeIntersectsKeyhole(nextElement->getAACube())) {
next.element = nextElement; next.element = nextElement;
return; return;
} }
@ -78,28 +75,25 @@ void DiffTraversal::Waypoint::getNextVisibleElementRepeat(
if (_nextIndex < NUMBER_OF_CHILDREN) { if (_nextIndex < NUMBER_OF_CHILDREN) {
EntityTreeElementPointer element = _weakElement.lock(); EntityTreeElementPointer element = _weakElement.lock();
if (element) { if (element) {
// No LOD truncation if we aren't using the view frustum while (_nextIndex < NUMBER_OF_CHILDREN) {
if (!view.usesViewFrustum) { EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex);
while (_nextIndex < NUMBER_OF_CHILDREN) { ++_nextIndex;
EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex); if (nextElement && nextElement->getLastChanged() > lastTime) {
++_nextIndex; if (!view.usesViewFrustum) {
if (nextElement && nextElement->getLastChanged() > lastTime) { // No LOD truncation if we aren't using the view frustum
next.element = nextElement; next.element = nextElement;
next.intersection = ViewFrustum::INSIDE; next.intersection = ViewFrustum::INSIDE;
return; return;
} } else {
} ViewFrustum::intersection intersection = view.viewFrustum.calculateCubeKeyholeIntersection(nextElement->getAACube());
} else { if (intersection != ViewFrustum::OUTSIDE) {
// check for LOD truncation // check for LOD truncation
float visibleLimit = boundaryDistanceForRenderLevel(element->getLevel() + view.lodLevelOffset, view.rootSizeScale); float renderAccuracy = calculateRenderAccuracy(view.viewFrustum.getPosition(),
float distance2 = glm::distance2(view.viewFrustum.getPosition(), element->getAACube().calcCenter()); nextElement->getAACube(),
if (distance2 < visibleLimit * visibleLimit) { view.rootSizeScale,
while (_nextIndex < NUMBER_OF_CHILDREN) { view.lodLevelOffset);
EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex);
++_nextIndex; if (renderAccuracy > 0.0f) {
if (nextElement && nextElement->getLastChanged() > lastTime) {
ViewFrustum::intersection intersection = view.viewFrustum.calculateCubeKeyholeIntersection(nextElement->getAACube());
if (intersection != ViewFrustum::OUTSIDE) {
next.element = nextElement; next.element = nextElement;
next.intersection = intersection; next.intersection = intersection;
return; return;
@ -123,21 +117,22 @@ void DiffTraversal::Waypoint::getNextVisibleElementDifferential(DiffTraversal::V
next.element = element; next.element = element;
next.intersection = ViewFrustum::INTERSECT; next.intersection = ViewFrustum::INTERSECT;
return; return;
} } else if (_nextIndex < NUMBER_OF_CHILDREN) {
if (_nextIndex < NUMBER_OF_CHILDREN) {
EntityTreeElementPointer element = _weakElement.lock(); EntityTreeElementPointer element = _weakElement.lock();
if (element) { if (element) {
// check for LOD truncation while (_nextIndex < NUMBER_OF_CHILDREN) {
int32_t level = element->getLevel() + view.lodLevelOffset; EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex);
float visibleLimit = boundaryDistanceForRenderLevel(level, view.rootSizeScale); ++_nextIndex;
float distance2 = glm::distance2(view.viewFrustum.getPosition(), element->getAACube().calcCenter()); if (nextElement) {
if (distance2 < visibleLimit * visibleLimit) { AACube cube = nextElement->getAACube();
while (_nextIndex < NUMBER_OF_CHILDREN) { if (view.viewFrustum.calculateCubeKeyholeIntersection(cube) != ViewFrustum::OUTSIDE) {
EntityTreeElementPointer nextElement = element->getChildAtIndex(_nextIndex); // check for LOD truncation
++_nextIndex; float renderAccuracy = calculateRenderAccuracy(view.viewFrustum.getPosition(),
if (nextElement) { cube,
AACube cube = nextElement->getAACube(); view.rootSizeScale,
if (view.viewFrustum.calculateCubeKeyholeIntersection(cube) != ViewFrustum::OUTSIDE) { view.lodLevelOffset);
if (renderAccuracy > 0.0f) {
ViewFrustum::intersection lastIntersection = lastView.viewFrustum.calculateCubeKeyholeIntersection(cube); ViewFrustum::intersection lastIntersection = lastView.viewFrustum.calculateCubeKeyholeIntersection(cube);
if (lastIntersection != ViewFrustum::INSIDE || nextElement->getLastChanged() > lastView.startTime) { if (lastIntersection != ViewFrustum::INSIDE || nextElement->getLastChanged() > lastView.startTime) {
next.element = nextElement; next.element = nextElement;
@ -148,10 +143,12 @@ void DiffTraversal::Waypoint::getNextVisibleElementDifferential(DiffTraversal::V
} else { } else {
// check for LOD truncation in the last traversal because // check for LOD truncation in the last traversal because
// we may need to traverse this element after all if the lastView skipped it for LOD // we may need to traverse this element after all if the lastView skipped it for LOD
int32_t lastLevel = element->getLevel() + lastView.lodLevelOffset; renderAccuracy = calculateRenderAccuracy(lastView.viewFrustum.getPosition(),
visibleLimit = boundaryDistanceForRenderLevel(lastLevel, lastView.rootSizeScale); cube,
distance2 = glm::distance2(lastView.viewFrustum.getPosition(), element->getAACube().calcCenter()); lastView.rootSizeScale,
if (distance2 >= visibleLimit * visibleLimit) { lastView.lodLevelOffset);
if (renderAccuracy <= 0.0f) {
next.element = nextElement; next.element = nextElement;
// element's intersection with lastView was effectively OUTSIDE // element's intersection with lastView was effectively OUTSIDE
next.intersection = ViewFrustum::OUTSIDE; next.intersection = ViewFrustum::OUTSIDE;

4
libraries/entities/src/DiffTraversal.h
View file

@ -68,8 +68,8 @@ public:
bool doesCurrentUseViewFrustum() const { return _currentView.usesViewFrustum; } bool doesCurrentUseViewFrustum() const { return _currentView.usesViewFrustum; }
float getCurrentRootSizeScale() const { return _currentView.rootSizeScale; } float getCurrentRootSizeScale() const { return _currentView.rootSizeScale; }
float getCompletedRootSizeScale() const { return _completedView.rootSizeScale; } float getCompletedRootSizeScale() const { return _completedView.rootSizeScale; }
float getCurrentLODOffset() const { return _currentView.lodLevelOffset; } int32_t getCurrentLODOffset() const { return _currentView.lodLevelOffset; }
float getCompletedLODOffset() const { return _completedView.lodLevelOffset; } int32_t getCompletedLODOffset() const { return _completedView.lodLevelOffset; }
uint64_t getStartOfCompletedTraversal() const { return _completedView.startTime; } uint64_t getStartOfCompletedTraversal() const { return _completedView.startTime; }
bool finished() const { return _path.empty(); } bool finished() const { return _path.empty(); }