OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0025675: Visualization - Fix problems and inefficiencies with frustum culling

Browse Source 
Removed unnecessary overlap check in traverse of layer items;
Slight optimization of calculations in overlap detection methods in OpenGl_BVHTreeSelector.
This commit is contained in:
vpa 2015-02-04 15:59:14 +03:00 committed by bugmaster
parent c7b59798ca
commit 14a35e5d91
2 changed files with 46 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
src/OpenGl/OpenGl_BVHTreeSelector.cxx
View File

@ -13,46 +13,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <limits>
#include <OpenGl_BVHTreeSelector.hxx> #include <OpenGl_BVHTreeSelector.hxx>
#include <OpenGl_BVHClipPrimitiveSet.hxx> #include <OpenGl_BVHClipPrimitiveSet.hxx>
#include <vector>
#include <algorithm>
// =======================================================================
// function : DotProduct
// purpose : Calculates a dot product of 4-dimensional vectors in homogeneous coordinates
// =======================================================================
static Standard_ShortReal DotProduct (const OpenGl_Vec4& theA,
const OpenGl_Vec4& theB)
{
return theA.x() * theB.x() + theA.y() * theB.y() + theA.z() * theB.z();
}
// =======================================================================
// function : BinarySign
// purpose :
// =======================================================================
static OpenGl_Vec4 BinarySign (const OpenGl_Vec4& theVec)
{
return OpenGl_Vec4 (theVec.x() > 0.0f ? 1.0f : 0.0f,
theVec.y() > 0.0f ? 1.0f : 0.0f,
theVec.z() > 0.0f ? 1.0f : 0.0f,
theVec.w() > 0.0f ? 1.0f : 0.0f);
}
// =======================================================================
// function : InversedBinarySign
// purpose :
// =======================================================================
static OpenGl_Vec4 InversedBinarySign (const OpenGl_Vec4& theVec)
{
return OpenGl_Vec4 (theVec.x() > 0.0f ? 0.0f : 1.0f,
theVec.y() > 0.0f ? 0.0f : 1.0f,
theVec.z() > 0.0f ? 0.0f : 1.0f,
theVec.w() > 0.0f ? 0.0f : 1.0f);
}
// ======================================================================= // =======================================================================
// function : OpenGl_BVHTreeSelector // function : OpenGl_BVHTreeSelector
// purpose : // purpose :
@ -182,35 +147,37 @@ Standard_ShortReal OpenGl_BVHTreeSelector::SignedPlanePointDistance (const OpenG
// ======================================================================= // =======================================================================
void OpenGl_BVHTreeSelector::CacheClipPtsProjections() void OpenGl_BVHTreeSelector::CacheClipPtsProjections()
{ {
Standard_ShortReal aProjectedVerts[ClipVerticesNB]; const Standard_Integer anIncFactor = myIsProjectionParallel ? 2 : 1;
for (Standard_Integer aPlaneIter = 0; aPlaneIter < PlanesNB; ++aPlaneIter) for (Standard_Integer aPlaneIter = 0; aPlaneIter < 5; aPlaneIter += anIncFactor)
{ {
const OpenGl_Vec4 aPlane = myClipPlanes[aPlaneIter]; const OpenGl_Vec4 aPlane = myClipPlanes[aPlaneIter];
Standard_ShortReal aMaxProj = -std::numeric_limits<Standard_ShortReal>::max();
Standard_ShortReal aMinProj = std::numeric_limits<Standard_ShortReal>::max();
for (Standard_Integer aCornerIter = 0; aCornerIter < ClipVerticesNB; ++aCornerIter) for (Standard_Integer aCornerIter = 0; aCornerIter < ClipVerticesNB; ++aCornerIter)
{ {
Standard_ShortReal aProjection = DotProduct (aPlane, myClipVerts[aCornerIter]); Standard_ShortReal aProjection = aPlane.x() * myClipVerts[aCornerIter].x() +
aProjectedVerts[aCornerIter] = aProjection; aPlane.y() * myClipVerts[aCornerIter].y() +
aPlane.z() * myClipVerts[aCornerIter].z();
aMaxProj = Max (aProjection, aMaxProj);
aMinProj = Min (aProjection, aMinProj);
} }
myMaxClipProjectionPts[aPlaneIter] = *std::max_element (aProjectedVerts, aProjectedVerts + ClipVerticesNB); myMaxClipProjectionPts[aPlaneIter] = aMaxProj;
myMinClipProjectionPts[aPlaneIter] = *std::min_element (aProjectedVerts, aProjectedVerts + ClipVerticesNB); myMinClipProjectionPts[aPlaneIter] = aMinProj;
} }
OpenGl_Vec4 aDimensions[3] =
{
OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 1.0f),
OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 1.0f),
OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 1.0f)
};
for (Standard_Integer aDim = 0; aDim < 3; ++aDim) for (Standard_Integer aDim = 0; aDim < 3; ++aDim)
{ {
Standard_ShortReal aMaxProj = -std::numeric_limits<Standard_ShortReal>::max();
Standard_ShortReal aMinProj = std::numeric_limits<Standard_ShortReal>::max();
for (Standard_Integer aCornerIter = 0; aCornerIter < ClipVerticesNB; ++aCornerIter) for (Standard_Integer aCornerIter = 0; aCornerIter < ClipVerticesNB; ++aCornerIter)
{ {
Standard_ShortReal aProjection = DotProduct (aDimensions[aDim], myClipVerts[aCornerIter]); Standard_ShortReal aProjection = aDim == 0 ? myClipVerts[aCornerIter].x()
aProjectedVerts[aCornerIter] = aProjection; : (aDim == 1 ? myClipVerts[aCornerIter].y() : myClipVerts[aCornerIter].z());
aMaxProj = Max (aProjection, aMaxProj);
aMinProj = Min (aProjection, aMinProj);
} }
myMaxOrthoProjectionPts[aDim] = *std::max_element (aProjectedVerts, aProjectedVerts + ClipVerticesNB); myMaxOrthoProjectionPts[aDim] = aMaxProj;
myMinOrthoProjectionPts[aDim] = *std::min_element (aProjectedVerts, aProjectedVerts + ClipVerticesNB); myMinOrthoProjectionPts[aDim] = aMinProj;
} }
} }
@ -225,59 +192,47 @@ Standard_Boolean OpenGl_BVHTreeSelector::Intersect (const OpenGl_Vec4& theMinPt,
// |_ E0 // |_ E0
// / // /
// E2 // E2
const OpenGl_Vec4 aShiftedBoxMax = theMaxPt - theMinPt;
Standard_ShortReal aBoxProjMax = 0.0f, aBoxProjMin = 0.0f;
Standard_ShortReal aFrustumProjMax = 0.0f, aFrustumProjMin = 0.0f;
// E0 test // E0 test
aBoxProjMax = aShiftedBoxMax.x(); if (theMinPt.x() > myMaxOrthoProjectionPts[0]
aFrustumProjMax = myMaxOrthoProjectionPts[0] - DotProduct (OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 1.0f), theMinPt); || theMaxPt.x() < myMinOrthoProjectionPts[0])
aFrustumProjMin = myMinOrthoProjectionPts[0] - DotProduct (OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 1.0f), theMinPt);
if (aBoxProjMin > aFrustumProjMax
|| aBoxProjMax < aFrustumProjMin)
{ {
return Standard_False; return Standard_False;
} }
// E1 test // E1 test
aBoxProjMax = aShiftedBoxMax.y(); if (theMinPt.y() > myMaxOrthoProjectionPts[1]
aFrustumProjMax = myMaxOrthoProjectionPts[1] - DotProduct (OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 1.0f), theMinPt); || theMaxPt.y() < myMinOrthoProjectionPts[1])
aFrustumProjMin = myMinOrthoProjectionPts[1] - DotProduct (OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 1.0f), theMinPt);
if (aBoxProjMin > aFrustumProjMax
|| aBoxProjMax < aFrustumProjMin)
{ {
return Standard_False; return Standard_False;
} }
// E2 test // E2 test
aBoxProjMax = aShiftedBoxMax.z(); if (theMinPt.z() > myMaxOrthoProjectionPts[2]
aFrustumProjMax = myMaxOrthoProjectionPts[2] - DotProduct (OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 1.0f), theMinPt); || theMaxPt.z() < myMinOrthoProjectionPts[2])
aFrustumProjMin = myMinOrthoProjectionPts[2] - DotProduct (OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 1.0f), theMinPt);
if (aBoxProjMin > aFrustumProjMax
|| aBoxProjMax < aFrustumProjMin)
{ {
return Standard_False; return Standard_False;
} }
Standard_ShortReal aBoxProjMax = 0.0f, aBoxProjMin = 0.0f;
const Standard_Integer anIncFactor = myIsProjectionParallel ? 2 : 1; const Standard_Integer anIncFactor = myIsProjectionParallel ? 2 : 1;
for (Standard_Integer aPlaneIter = 0; aPlaneIter < 5; aPlaneIter += anIncFactor) for (Standard_Integer aPlaneIter = 0; aPlaneIter < 5; aPlaneIter += anIncFactor)
{ {
OpenGl_Vec4 aPlane = myClipPlanes[aPlaneIter]; OpenGl_Vec4 aPlane = myClipPlanes[aPlaneIter];
OpenGl_Vec4 aPt1 (0.0f), aPt2 (0.0f); aBoxProjMax = (aPlane.x() > 0.f ? (aPlane.x() * theMaxPt.x()) : aPlane.x() * theMinPt.x()) +
aPt1 = BinarySign (aPlane) * aShiftedBoxMax; (aPlane.y() > 0.f ? (aPlane.y() * theMaxPt.y()) : aPlane.y() * theMinPt.y()) +
aBoxProjMax = DotProduct (aPlane, aPt1); (aPlane.z() > 0.f ? (aPlane.z() * theMaxPt.z()) : aPlane.z() * theMinPt.z());
aFrustumProjMax = myMaxClipProjectionPts[aPlaneIter] - DotProduct (aPlane, theMinPt); if (aBoxProjMax > myMinClipProjectionPts[aPlaneIter]
aFrustumProjMin = myMinClipProjectionPts[aPlaneIter] - DotProduct (aPlane, theMinPt); && aBoxProjMax < myMaxClipProjectionPts[aPlaneIter])
if (aFrustumProjMin < aBoxProjMax
&& aBoxProjMax < aFrustumProjMax)
{ {
continue; continue;
} }
aPt2 = InversedBinarySign (aPlane) * aShiftedBoxMax; aBoxProjMin = (aPlane.x() < 0.f ? aPlane.x() * theMaxPt.x() : aPlane.x() * theMinPt.x()) +
aBoxProjMin = DotProduct (aPlane, aPt2); (aPlane.y() < 0.f ? aPlane.y() * theMaxPt.y() : aPlane.y() * theMinPt.y()) +
if (aBoxProjMin > aFrustumProjMax (aPlane.z() < 0.f ? aPlane.z() * theMaxPt.z() : aPlane.z() * theMinPt.z());
|| aBoxProjMax < aFrustumProjMin) if (aBoxProjMin > myMaxClipProjectionPts[aPlaneIter]
|| aBoxProjMax < myMinClipProjectionPts[aPlaneIter])
{ {
return Standard_False; return Standard_False;
} }

23
src/OpenGl/OpenGl_Layer.cxx
View File

@ -207,8 +207,7 @@ void OpenGl_Layer::traverse (OpenGl_BVHTreeSelector& theSelector) const
&& isRightChildIn) && isRightChildIn)
{ {
aNode = myBVHIsLeftChildQueuedFirst ? aLeftChildIdx : aRightChildIdx; aNode = myBVHIsLeftChildQueuedFirst ? aLeftChildIdx : aRightChildIdx;
++aHead; aStack[++aHead] = myBVHIsLeftChildQueuedFirst ? aRightChildIdx : aLeftChildIdx;
aStack[aHead] = myBVHIsLeftChildQueuedFirst ? aRightChildIdx : aLeftChildIdx;
myBVHIsLeftChildQueuedFirst = !myBVHIsLeftChildQueuedFirst; myBVHIsLeftChildQueuedFirst = !myBVHIsLeftChildQueuedFirst;
} }
else if (isLeftChildIn else if (isLeftChildIn
@ -223,25 +222,19 @@ void OpenGl_Layer::traverse (OpenGl_BVHTreeSelector& theSelector) const
return; return;
} }
aNode = aStack[aHead]; aNode = aStack[aHead--];
--aHead;
} }
} }
else else
{ {
if (theSelector.Intersect (aBVHTree->MinPoint (aNode), Standard_Integer aIdx = aBVHTree->BegPrimitive (aNode);
aBVHTree->MaxPoint (aNode))) myBVHPrimitives.GetStructureById (aIdx)->MarkAsNotCulled();
if (aHead < 0)
{ {
Standard_Integer aIdx = aBVHTree->BegPrimitive (aNode); return;
myBVHPrimitives.GetStructureById (aIdx)->MarkAsNotCulled();
if (aHead < 0)
{
return;
}
aNode = aStack[aHead];
--aHead;
} }
aNode = aStack[aHead--];
} }
} }
} }