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

0024503: TKOpenGl - Porting ray-tracing component on BVH package

Browse Source 
Updated test case v3d/raytrace/bug24130. The new version checks correctness of shadows.
This commit is contained in:
dbp 2014-01-30 12:53:54 +04:00 committed by bugmaster
parent 05d7de534a
commit 265d4508bd
12 changed files with 1769 additions and 2216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/BVH/BVH_Geometry.lxx
View File

@ -92,13 +92,8 @@ void BVH_Geometry<T, N>::Update()
return; return;
} }
BVH_Box<T, N> aBox; myBuilder->Build (this, myBVH.operator->(), Box());
for (Standard_Integer anIndex = 0; anIndex < BVH_ObjectSet<T, N>::myObjects.Size(); ++anIndex)
{
aBox.Combine (BVH_ObjectSet<T, N>::myObjects.Value (anIndex)->Box());
}
myBuilder->Build (this, myBVH.operator->(), aBox);
myIsDirty = Standard_False; myIsDirty = Standard_False;
} }

3
src/OpenGl/FILES
View File

@ -133,11 +133,8 @@ Handle_OpenGl_ShaderObject.hxx
Handle_OpenGl_ShaderProgram.hxx Handle_OpenGl_ShaderProgram.hxx
Handle_OpenGl_ShaderManager.hxx Handle_OpenGl_ShaderManager.hxx
OpenGl_Cl.hxx OpenGl_Cl.hxx
OpenGl_AABB.hxx
OpenGl_AABB.cxx
OpenGl_SceneGeometry.hxx OpenGl_SceneGeometry.hxx
OpenGl_SceneGeometry.cxx OpenGl_SceneGeometry.cxx
OpenGl_RaytraceTypes.hxx
OpenGl_RaytraceSource.cxx OpenGl_RaytraceSource.cxx
OpenGl_Workspace_Raytrace.cxx OpenGl_Workspace_Raytrace.cxx
OpenGl_Flipper.hxx OpenGl_Flipper.hxx

132
src/OpenGl/OpenGl_AABB.cxx
View File

@ -1,132 +0,0 @@
// Created on: 2013-08-27
// Created by: Denis BOGOLEPOV
// Copyright (c) 2013 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef HAVE_OPENCL
#include <Standard_ShortReal.hxx>
#include <OpenGl_AABB.hxx>
OpenGl_AABB::OpenGl_AABB() : myMinPoint(),
myMaxPoint(),
myIsValid (false)
{ }
OpenGl_AABB::OpenGl_AABB (const OpenGl_RTVec4f& thePoint) : myMinPoint (thePoint),
myMaxPoint (thePoint),
myIsValid (true)
{ }
OpenGl_AABB::OpenGl_AABB (const OpenGl_RTVec4f& theMinPoint,
const OpenGl_RTVec4f& theMaxPoint) : myMinPoint (theMinPoint),
myMaxPoint (theMaxPoint),
myIsValid (true)
{ }
OpenGl_AABB::OpenGl_AABB (const OpenGl_AABB& theVolume) : myMinPoint (theVolume.myMinPoint),
myMaxPoint (theVolume.myMaxPoint),
myIsValid (theVolume.myIsValid)
{ }
void OpenGl_AABB::Add (const OpenGl_RTVec4f& thePoint)
{
if (!myIsValid)
{
myMinPoint = thePoint;
myMaxPoint = thePoint;
myIsValid = true;
}
else
{
myMinPoint = OpenGl_RTVec4f (Min (myMinPoint.x(), thePoint.x()),
Min (myMinPoint.y(), thePoint.y()),
Min (myMinPoint.z(), thePoint.z()),
1.f);
myMaxPoint = OpenGl_RTVec4f (Max (myMaxPoint.x(), thePoint.x()),
Max (myMaxPoint.y(), thePoint.y()),
Max (myMaxPoint.z(), thePoint.z()),
1.f);
}
}
void OpenGl_AABB::Combine (const OpenGl_AABB& theVolume)
{
if (!theVolume.myIsValid)
return;
if (!myIsValid)
{
myMinPoint = theVolume.myMinPoint;
myMaxPoint = theVolume.myMaxPoint;
myIsValid = true;
}
else
{
myMinPoint = OpenGl_RTVec4f (Min (myMinPoint.x(), theVolume.myMinPoint.x()),
Min (myMinPoint.y(), theVolume.myMinPoint.y()),
Min (myMinPoint.z(), theVolume.myMinPoint.z()),
1.f);
myMaxPoint = OpenGl_RTVec4f (Max (myMaxPoint.x(), theVolume.myMaxPoint.x()),
Max (myMaxPoint.y(), theVolume.myMaxPoint.y()),
Max (myMaxPoint.z(), theVolume.myMaxPoint.z()),
1.f);
}
}
OpenGl_AABB OpenGl_AABB::Added (const OpenGl_RTVec4f& thePoint) const
{
OpenGl_AABB result (*this);
result.Add (thePoint);
return result;
}
OpenGl_AABB OpenGl_AABB::Combined (const OpenGl_AABB& theVolume) const
{
OpenGl_AABB result (*this);
result.Combine (theVolume);
return result;
}
void OpenGl_AABB::Clear()
{
myIsValid = false;
}
OpenGl_RTVec4f OpenGl_AABB::Size() const
{
return myMaxPoint - myMinPoint;
}
float OpenGl_AABB::Area() const
{
const float aXLen = myMaxPoint.x() - myMinPoint.x();
const float aYLen = myMaxPoint.y() - myMinPoint.y();
const float aZLen = myMaxPoint.z() - myMinPoint.z();
return ( aXLen * aYLen + aXLen * aZLen + aZLen * aYLen ) * 2.f;
}
#endif

83
src/OpenGl/OpenGl_AABB.hxx
View File

@ -1,83 +0,0 @@
// Created on: 2013-08-27
// Created by: Denis BOGOLEPOV
// Copyright (c) 2013 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _OpenGl_AABB_Header
#define _OpenGl_AABB_Header
#include <OpenGl_RaytraceTypes.hxx>
//! Axis aligned bounding box (AABB).
class OpenGl_AABB
{
public:
//! Creates default (invalid) bounding volume.
OpenGl_AABB();
//! Creates bounding volume of given point.
OpenGl_AABB (const OpenGl_RTVec4f& thePoint);
//! Creates copy of another bounding volume.
OpenGl_AABB (const OpenGl_AABB& theVolume);
//! Creates bounding volume from min and max points.
OpenGl_AABB (const OpenGl_RTVec4f& theMinPoint,
const OpenGl_RTVec4f& theMaxPoint);
//! Is object represents uninitialized volume?
bool IsVoid() const { return !myIsValid; }
//! Appends new point to the volume.
void Add (const OpenGl_RTVec4f& theVector);
//! Combines the volume with another volume.
void Combine (const OpenGl_AABB& theVolume);
//! Returns new volume created by appending a point to current volume.
OpenGl_AABB Added (const OpenGl_RTVec4f& thePoint) const;
//! Returns new volume created by combining with specified volume.
OpenGl_AABB Combined (const OpenGl_AABB& theVolume) const;
//! Clears bounding volume (makes object invalid).
void Clear();
//! Evaluates surface area of bounding volume.
float Area() const;
//! Return diagonal of bounding volume.
OpenGl_RTVec4f Size() const;
//! Returns minimum point of bounding volume.
const OpenGl_RTVec4f& CornerMin() const { return myMinPoint; }
//! Returns maximum point of bounding volume.
const OpenGl_RTVec4f& CornerMax() const { return myMaxPoint; }
//! Returns minimum point of bounding volume.
OpenGl_RTVec4f& CornerMin() { return myMinPoint; }
//! Returns maximum point of bounding volume.
OpenGl_RTVec4f& CornerMax() { return myMaxPoint; }
private:
//! Minimum point of bounding volume.
OpenGl_RTVec4f myMinPoint;
//! Maximum point of bounding volume.
OpenGl_RTVec4f myMaxPoint;
//! Is bounding volume valid (up to date)?
bool myIsValid;
};
#endif

2
src/OpenGl/OpenGl_Context.cxx
View File

@ -1257,7 +1257,7 @@ void OpenGl_Context::ReleaseDelayed()
myReleaseQueue->Pop(); myReleaseQueue->Pop();
} }
// release delayed shared resoruces // release delayed shared resources
NCollection_Vector<TCollection_AsciiString> aDeadList; NCollection_Vector<TCollection_AsciiString> aDeadList;
for (NCollection_DataMap<TCollection_AsciiString, Standard_Integer>::Iterator anIter (*myDelayed); for (NCollection_DataMap<TCollection_AsciiString, Standard_Integer>::Iterator anIter (*myDelayed);
anIter.More(); anIter.Next()) anIter.More(); anIter.Next())

1027
src/OpenGl/OpenGl_RaytraceSource.cxx
View File

File diff suppressed because it is too large Load Diff

41
src/OpenGl/OpenGl_RaytraceTypes.hxx
View File

@ -1,41 +0,0 @@
// Created on: 2013-10-15
// Created by: Denis BOGOLEPOV
// Copyright (c) 2013 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _OpenGl_RaytraceTypes_Header
#define _OpenGl_RaytraceTypes_Header
#include <vector>
#include <NCollection_Vec4.hxx>
#include <NCollection_StdAllocator.hxx>
//! 4D vector of integers.
typedef NCollection_Vec4<int> OpenGl_RTVec4i;
//! 4D vector of floats.
typedef NCollection_Vec4<float> OpenGl_RTVec4f;
//! 4D vector of doubles.
typedef NCollection_Vec4<double> OpenGl_RTVec4d;
//! Array of 4D integer vectors.
typedef std::vector<OpenGl_RTVec4i,
NCollection_StdAllocator<OpenGl_RTVec4i> > OpenGl_RTArray4i;
//! Array of 4D floating point vectors.
typedef std::vector<OpenGl_RTVec4f,
NCollection_StdAllocator<OpenGl_RTVec4f> > OpenGl_RTArray4f;
#endif

737
src/OpenGl/OpenGl_SceneGeometry.cxx
View File

@ -19,25 +19,25 @@
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
#include <limits> #include <Standard_Assert.hxx>
#ifdef HAVE_TBB
#include <tbb/tbb.h>
#endif
#include <OpenGl_SceneGeometry.hxx> #include <OpenGl_SceneGeometry.hxx>
//! Use this macro to output BVH profiling info
//#define BVH_PRINT_INFO
#ifdef BVH_PRINT_INFO
#include <OSD_Timer.hxx>
#endif
namespace namespace
{ {
//! Number of node bins per axis.
static const int THE_NUMBER_OF_BINS = 32;
//! Max number of triangles per leaf node.
static const int THE_MAX_LEAF_TRIANGLES = 4;
//! Useful constant for null integer 4D vector.
static const OpenGl_RTVec4i THE_ZERO_VEC_4I;
//! Useful constant for null floating-point 4D vector. //! Useful constant for null floating-point 4D vector.
static const OpenGl_RTVec4f THE_ZERO_VEC_4F; static const BVH_Vec4f ZERO_VEC_4F;
}; };
// ======================================================================= // =======================================================================
@ -45,29 +45,29 @@ namespace
// purpose : Creates new default material // purpose : Creates new default material
// ======================================================================= // =======================================================================
OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial() OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial()
: Ambient (THE_ZERO_VEC_4F), : Ambient (ZERO_VEC_4F),
Diffuse (THE_ZERO_VEC_4F), Diffuse (ZERO_VEC_4F),
Specular (THE_ZERO_VEC_4F), Specular (ZERO_VEC_4F),
Emission (THE_ZERO_VEC_4F), Emission (ZERO_VEC_4F),
Reflection (THE_ZERO_VEC_4F), Reflection (ZERO_VEC_4F),
Refraction (THE_ZERO_VEC_4F), Refraction (ZERO_VEC_4F),
Transparency (THE_ZERO_VEC_4F) Transparency (ZERO_VEC_4F)
{ } { }
// ======================================================================= // =======================================================================
// function : OpenGl_RaytraceMaterial // function : OpenGl_RaytraceMaterial
// purpose : Creates new material with specified properties // purpose : Creates new material with specified properties
// ======================================================================= // =======================================================================
OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbient, OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
const OpenGl_RTVec4f& theDiffuse, const BVH_Vec4f& theDiffuse,
const OpenGl_RTVec4f& theSpecular) const BVH_Vec4f& theSpecular)
: Ambient (theAmbient), : Ambient (theAmbient),
Diffuse (theDiffuse), Diffuse (theDiffuse),
Specular (theSpecular), Specular (theSpecular),
Emission (THE_ZERO_VEC_4F), Emission (ZERO_VEC_4F),
Reflection (THE_ZERO_VEC_4F), Reflection (ZERO_VEC_4F),
Refraction (THE_ZERO_VEC_4F), Refraction (ZERO_VEC_4F),
Transparency (THE_ZERO_VEC_4F) Transparency (ZERO_VEC_4F)
{ {
// //
} }
@ -76,17 +76,17 @@ OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbie
// function : OpenGl_RaytraceMaterial // function : OpenGl_RaytraceMaterial
// purpose : Creates new material with specified properties // purpose : Creates new material with specified properties
// ======================================================================= // =======================================================================
OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbient, OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
const OpenGl_RTVec4f& theDiffuse, const BVH_Vec4f& theDiffuse,
const OpenGl_RTVec4f& theSpecular, const BVH_Vec4f& theSpecular,
const OpenGl_RTVec4f& theEmission, const BVH_Vec4f& theEmission,
const OpenGl_RTVec4f& theTranspar) const BVH_Vec4f& theTranspar)
: Ambient (theAmbient), : Ambient (theAmbient),
Diffuse (theDiffuse), Diffuse (theDiffuse),
Specular (theSpecular), Specular (theSpecular),
Emission (theEmission), Emission (theEmission),
Reflection (THE_ZERO_VEC_4F), Reflection (ZERO_VEC_4F),
Refraction (THE_ZERO_VEC_4F), Refraction (ZERO_VEC_4F),
Transparency (theTranspar) Transparency (theTranspar)
{ {
// //
@ -96,13 +96,13 @@ OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbie
// function : OpenGl_RaytraceMaterial // function : OpenGl_RaytraceMaterial
// purpose : Creates new material with specified properties // purpose : Creates new material with specified properties
// ======================================================================= // =======================================================================
OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbient, OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
const OpenGl_RTVec4f& theDiffuse, const BVH_Vec4f& theDiffuse,
const OpenGl_RTVec4f& theSpecular, const BVH_Vec4f& theSpecular,
const OpenGl_RTVec4f& theEmission, const BVH_Vec4f& theEmission,
const OpenGl_RTVec4f& theTranspar, const BVH_Vec4f& theTranspar,
const OpenGl_RTVec4f& theReflection, const BVH_Vec4f& theReflection,
const OpenGl_RTVec4f& theRefraction) const BVH_Vec4f& theRefraction)
: Ambient (theAmbient), : Ambient (theAmbient),
Diffuse (theDiffuse), Diffuse (theDiffuse),
Specular (theSpecular), Specular (theSpecular),
@ -118,587 +118,214 @@ OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbie
// function : OpenGl_LightSource // function : OpenGl_LightSource
// purpose : Creates new light source // purpose : Creates new light source
// ======================================================================= // =======================================================================
OpenGl_RaytraceLight::OpenGl_RaytraceLight (const OpenGl_RTVec4f& theAmbient) OpenGl_RaytraceLight::OpenGl_RaytraceLight (const BVH_Vec4f& theDiffuse,
: Ambient (theAmbient) const BVH_Vec4f& thePosition)
{
//
}
// =======================================================================
// function : OpenGl_LightSource
// purpose : Creates new light source
// =======================================================================
OpenGl_RaytraceLight::OpenGl_RaytraceLight (const OpenGl_RTVec4f& theDiffuse,
const OpenGl_RTVec4f& thePosition)
: Diffuse (theDiffuse), : Diffuse (theDiffuse),
Position (thePosition) Position (thePosition)
{ {
// //
} }
// =======================================================================
// function : Center
// purpose : Returns centroid of specified triangle
// =======================================================================
OpenGl_RTVec4f OpenGl_RaytraceScene::Center (const int theTriangle) const
{
const OpenGl_RTVec4i& anIndex = Triangles [theTriangle];
return ( Vertices[anIndex.x()] +
Vertices[anIndex.y()] +
Vertices[anIndex.z()] ) * ( 1.f / 3.f );
}
// =======================================================================
// function : CenterAxis
// purpose : Returns centroid of specified triangle
// =======================================================================
float OpenGl_RaytraceScene::CenterAxis (const int theTriangle,
const int theAxis) const
{
const OpenGl_RTVec4i& anIndex = Triangles [theTriangle];
return ( Vertices[anIndex.x()][theAxis] +
Vertices[anIndex.y()][theAxis] +
Vertices[anIndex.z()][theAxis] ) * ( 1.f / 3.f );
}
// =======================================================================
// function : Box
// purpose : Returns AABB of specified triangle
// =======================================================================
OpenGl_AABB OpenGl_RaytraceScene::Box (const int theTriangle) const
{
const OpenGl_RTVec4i& anIndex = Triangles[theTriangle];
const OpenGl_RTVec4f& pA = Vertices[anIndex.x()];
const OpenGl_RTVec4f& pB = Vertices[anIndex.y()];
const OpenGl_RTVec4f& pC = Vertices[anIndex.z()];
OpenGl_AABB aBox (pA);
aBox.Add (pB);
aBox.Add (pC);
return aBox;
}
// ======================================================================= // =======================================================================
// function : Clear // function : Clear
// purpose : Clears all scene geometry data // purpose : Clears ray-tracing geometry
// ======================================================================= // =======================================================================
void OpenGl_RaytraceScene::Clear() void OpenGl_RaytraceGeometry::Clear()
{ {
AABB.Clear(); BVH_Geometry<Standard_ShortReal, 4>::BVH_Geometry::Clear();
OpenGl_RTArray4f anEmptyNormals; std::vector<OpenGl_RaytraceLight,
Normals.swap (anEmptyNormals); NCollection_StdAllocator<OpenGl_RaytraceLight> > anEmptySources;
OpenGl_RTArray4f anEmptyVertices; Sources.swap (anEmptySources);
Vertices.swap (anEmptyVertices);
OpenGl_RTArray4i anEmptyTriangles;
Triangles.swap (anEmptyTriangles);
std::vector<OpenGl_RaytraceMaterial, std::vector<OpenGl_RaytraceMaterial,
NCollection_StdAllocator<OpenGl_RaytraceMaterial> > anEmptyMaterials; NCollection_StdAllocator<OpenGl_RaytraceMaterial> > anEmptyMaterials;
Materials.swap (anEmptyMaterials); Materials.swap (anEmptyMaterials);
} }
// ======================================================================= #ifdef HAVE_TBB
// function : OpenGl_Node
// purpose : Creates new empty BVH node struct OpenGL_BVHParallelBuilder
// =======================================================================
OpenGl_BVHNode::OpenGl_BVHNode()
: myMinPoint (THE_ZERO_VEC_4F),
myMaxPoint (THE_ZERO_VEC_4F),
myDataRcrd (THE_ZERO_VEC_4I)
{ {
// BVH_ObjectSet<Standard_ShortReal, 4>* Set;
}
// ======================================================================= OpenGL_BVHParallelBuilder (BVH_ObjectSet<Standard_ShortReal, 4>* theSet)
// function : OpenGl_Node : Set (theSet)
// purpose : Creates new BVH node with specified data
// =======================================================================
OpenGl_BVHNode::OpenGl_BVHNode (const OpenGl_RTVec4f& theMinPoint,
const OpenGl_RTVec4f& theMaxPoint,
const OpenGl_RTVec4i& theDataRcrd)
: myMinPoint (theMinPoint),
myMaxPoint (theMaxPoint),
myDataRcrd (theDataRcrd)
{
//
}
// =======================================================================
// function : OpenGl_Node
// purpose : Creates new leaf BVH node with specified data
// =======================================================================
OpenGl_BVHNode::OpenGl_BVHNode (const OpenGl_AABB& theAABB,
const int theBegTriangle,
const int theEndTriangle)
: myMinPoint (theAABB.CornerMin()),
myMaxPoint (theAABB.CornerMax()),
myDataRcrd (1,
theBegTriangle,
theEndTriangle,
0)
{
//
}
// =======================================================================
// function : OpenGl_Node
// purpose : Creates new leaf BVH node with specified data
// =======================================================================
OpenGl_BVHNode::OpenGl_BVHNode (const OpenGl_RTVec4f& theMinPoint,
const OpenGl_RTVec4f& theMaxPoint,
const int theBegTriangle,
const int theEndTriangle)
: myMinPoint (theMinPoint),
myMaxPoint (theMaxPoint),
myDataRcrd (1,
theBegTriangle,
theEndTriangle,
0)
{
//
}
// =======================================================================
// function : CleanUp
// purpose : Removes all tree nodes
// =======================================================================
void OpenGl_BVH::CleanUp()
{
OpenGl_RTArray4f anEmptyMinPointBuffer;
myMinPointBuffer.swap (anEmptyMinPointBuffer);
OpenGl_RTArray4f anEmptyMaxPointBuffer;
myMaxPointBuffer.swap (anEmptyMaxPointBuffer);
OpenGl_RTArray4i anEmptyDataRcrdBuffer;
myDataRcrdBuffer.swap (anEmptyDataRcrdBuffer);
}
// =======================================================================
// function : Node
// purpose : Returns node with specified index
// =======================================================================
OpenGl_BVHNode OpenGl_BVH::Node (const int theIndex) const
{
return OpenGl_BVHNode (myMinPointBuffer[theIndex],
myMaxPointBuffer[theIndex],
myDataRcrdBuffer[theIndex]);
}
// =======================================================================
// function : SetNode
// purpose : Replaces node with specified index
// =======================================================================
void OpenGl_BVH::SetNode (const int theIndex,
const OpenGl_BVHNode& theNode)
{
if (theIndex < static_cast<int> (myMinPointBuffer.size()))
{ {
myMinPointBuffer[theIndex] = theNode.myMinPoint; //
myMaxPointBuffer[theIndex] = theNode.myMaxPoint;
myDataRcrdBuffer[theIndex] = theNode.myDataRcrd;
} }
}
// ======================================================================= void operator() (const tbb::blocked_range<size_t>& theRange) const
// function : PushNode {
// purpose : Adds new node to the tree for (size_t anObjectIdx = theRange.begin(); anObjectIdx != theRange.end(); ++anObjectIdx)
// ======================================================================= {
int OpenGl_BVH::PushNode (const OpenGl_BVHNode& theNode) OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
{ Set->Objects().ChangeValue (static_cast<Standard_Integer> (anObjectIdx)).operator->());
myMinPointBuffer.push_back (theNode.myMinPoint);
myMaxPointBuffer.push_back (theNode.myMaxPoint); if (aTriangleSet != NULL)
myDataRcrdBuffer.push_back (theNode.myDataRcrd); {
return static_cast<int> (myDataRcrdBuffer.size() - 1); aTriangleSet->BVH();
} }
}
}
};
// =======================================================================
// function : OpenGl_NodeBuildTask
// purpose : Creates new node building task
// =======================================================================
OpenGl_BVHNodeTask::OpenGl_BVHNodeTask()
: NodeToBuild (0),
BegTriangle (0),
EndTriangle (0)
{
//
}
// =======================================================================
// function : OpenGl_NodeBuildTask
// purpose : Creates new node building task
// =======================================================================
OpenGl_BVHNodeTask::OpenGl_BVHNodeTask (const int theNodeToBuild,
const int theBegTriangle,
const int theEndTriangle)
: NodeToBuild (theNodeToBuild),
BegTriangle (theBegTriangle),
EndTriangle (theEndTriangle)
{
//
}
// =======================================================================
// function : OpenGl_BinnedBVHBuilder
// purpose : Creates new binned BVH builder
// =======================================================================
OpenGl_BinnedBVHBuilder::OpenGl_BinnedBVHBuilder()
: myMaxDepth (30)
{
//
}
// =======================================================================
// function : ~OpenGl_BinnedBVHBuilder
// purpose : Releases binned BVH builder
// =======================================================================
OpenGl_BinnedBVHBuilder::~OpenGl_BinnedBVHBuilder()
{
//
}
#define BVH_DEBUG_OUTPUT_
#if defined( BVH_DEBUG_OUTPUT )
#include <iostream>
#endif #endif
// ======================================================================= // =======================================================================
// function : ReinterpretIntAsFloat // function : ProcessAcceleration
// purpose : Reinterprets bits of integer value as floating-point value // purpose : Performs post-processing of high-level BVH
// ======================================================================= // =======================================================================
inline float ReinterpretIntAsFloat (int theValue) Standard_Boolean OpenGl_RaytraceGeometry::ProcessAcceleration()
{ {
return *reinterpret_cast< float* > (&theValue); #ifdef BVH_PRINT_INFO
} OSD_Timer aTimer;
#endif
MarkDirty(); // force BVH rebuilding
// ======================================================================= #ifdef BVH_PRINT_INFO
// function : Build aTimer.Reset();
// purpose : Builds BVH tree using binned SAH algorithm aTimer.Start();
// =======================================================================
void OpenGl_BinnedBVHBuilder::Build (OpenGl_RaytraceScene& theGeometry,
const float theEpsilon)
{
CleanUp();
#ifdef BVH_DEBUG_OUTPUT
std::cout << "Start building BVH..." << std::endl;
std::cout << "Triangles: " << theGeometry.Triangles.size() << std::endl;
#endif #endif
if (theGeometry.Triangles.size() == 0) #ifdef HAVE_TBB
return; // If Intel TBB is available, perform the preliminary
// construction of bottom-level scene BVHs
tbb::parallel_for (tbb::blocked_range<size_t> (0, Size()),
OpenGL_BVHParallelBuilder (this));
#endif
for (Standard_Integer anObjectIdx = 0; anObjectIdx < Size(); ++anObjectIdx)
{
OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
myObjects.ChangeValue (anObjectIdx).operator->());
// Create root node with all scene triangles Standard_ASSERT_RETURN (aTriangleSet != NULL,
OpenGl_AABB anAABB = theGeometry.AABB; "Error! Failed to get triangulation of OpenGL element", Standard_False);
anAABB.CornerMin() = OpenGl_RTVec4f (anAABB.CornerMin().x() - theEpsilon,
anAABB.CornerMin().y() - theEpsilon, Standard_ASSERT_RETURN (!aTriangleSet->BVH().IsNull(),
anAABB.CornerMin().z() - theEpsilon, "Error! Failed to update bottom-level BVH of OpenGL element", Standard_False);
1.0f); }
anAABB.CornerMax() = OpenGl_RTVec4f (anAABB.CornerMax().x() + theEpsilon,
anAABB.CornerMax().y() + theEpsilon,
anAABB.CornerMax().z() + theEpsilon,
1.0f);
myTree.PushNode (OpenGl_BVHNode (anAABB, 0, static_cast<int> (theGeometry.Triangles.size() - 1)));
#ifdef BVH_DEBUG_OUTPUT #ifdef BVH_PRINT_INFO
std::cout << "Push root node: [" << 0 << ", " << aTimer.Stop();
theGeometry.Triangles.size() - 1 << "]" << std::endl;
std::cout << "Updating bottom-level BVHs (sec): " <<
aTimer.ElapsedTime() << std::endl;
#endif #endif
// Setup splitting task for the root node #ifdef BVH_PRINT_INFO
myNodeTasksQueue.push_back (OpenGl_BVHNodeTask (0, 0, static_cast<int> (theGeometry.Triangles.size() - 1))); aTimer.Reset();
aTimer.Start();
// Building nodes while tasks queue is not empty
for (int aTaskId = 0; aTaskId < static_cast<int> (myNodeTasksQueue.size()); ++aTaskId)
{
BuildNode (theGeometry, aTaskId);
}
// Write support data to optimize traverse
for (int aNode = 0; aNode < static_cast<int> (myTree.DataRcrdBuffer().size()); ++aNode)
{
OpenGl_RTVec4i aData = myTree.DataRcrdBuffer()[aNode];
myTree.MinPointBuffer()[aNode].w() = ReinterpretIntAsFloat (aData[0] ? aData[1] : -aData[1]);
myTree.MaxPointBuffer()[aNode].w() = ReinterpretIntAsFloat (aData[0] ? aData[2] : -aData[2]);
}
}
// =======================================================================
// function : CleanUp
// purpose : Clears previously built tree
// =======================================================================
void OpenGl_BinnedBVHBuilder::CleanUp()
{
myTree.CleanUp();
myNodeTasksQueue.clear();
}
// =======================================================================
// function : SetMaxDepth
// purpose : Sets maximum tree depth
// =======================================================================
void OpenGl_BinnedBVHBuilder::SetMaxDepth (const int theMaxDepth)
{
if (theMaxDepth > 1 && theMaxDepth < 30)
{
myMaxDepth = theMaxDepth - 1;
}
}
//! Minimum node size to split.
static const float THE_NODE_MIN_SIZE = 1e-4f;
// =======================================================================
// function : BuildNode
// purpose : Builds node using task info
// =======================================================================
void OpenGl_BinnedBVHBuilder::BuildNode (OpenGl_RaytraceScene& theGeometry,
const int theTask)
{
OpenGl_BVHNodeTask aTask = myNodeTasksQueue[theTask];
OpenGl_BVHNode aNode = myTree.Node (aTask.NodeToBuild);
#ifdef BVH_DEBUG_OUTPUT
std::cout << "Build node " << aTask.NodeToBuild << ": [" <<
aTask.BegTriangle << ", " << aTask.EndTriangle << "]" << std::endl;
#endif #endif
OpenGl_AABB anAABB (aNode.MinPoint(), aNode.MaxPoint()); NCollection_Handle<BVH_Tree<Standard_ShortReal, 4> > aBVH = BVH();
const OpenGl_RTVec4f aNodeSize = anAABB.Size();
const float aNodeArea = anAABB.Area();
// Parameters for storing best split #ifdef BVH_PRINT_INFO
float aMinSplitCost = std::numeric_limits<float>::max(); aTimer.Stop();
int aMinSplitAxis = -1; std::cout << "Updating high-level BVH (sec): " <<
int aMinSplitIndex = 0; aTimer.ElapsedTime() << std::endl;
int aMinSplitLftCount = 0; #endif
int aMinSplitRghCount = 0;
OpenGl_AABB aMinSplitLftAABB; Standard_ASSERT_RETURN (!aBVH.IsNull(),
OpenGl_AABB aMinSplitRghAABB; "Error! Failed to update high-level BVH of ray-tracing scene", Standard_False);
// Find best split Standard_Integer aVerticesOffset = 0;
for (int anAxis = 0; anAxis < 3; ++anAxis) Standard_Integer aElementsOffset = 0;
Standard_Integer aBVHNodesOffset = 0;
for (Standard_Integer aNodeIdx = 0; aNodeIdx < aBVH->Length(); ++aNodeIdx)
{ {
if (aNodeSize[anAxis] <= THE_NODE_MIN_SIZE) if (!aBVH->IsOuter (aNodeIdx))
continue; continue;
OpenGl_BinVector aBins (THE_NUMBER_OF_BINS); Standard_ASSERT_RETURN (aBVH->BegPrimitive (aNodeIdx) == aBVH->EndPrimitive (aNodeIdx),
GetSubVolumes (theGeometry, aNode, aBins, anAxis); "Error! Invalid leaf node in high-level BVH (contains several objects)", Standard_False);
// Choose the best split (with minimum SAH cost) Standard_Integer anObjectIdx = aBVH->BegPrimitive (aNodeIdx);
for (int aSplit = 1; aSplit < THE_NUMBER_OF_BINS; ++aSplit)
{
int aLftCount = 0;
int aRghCount = 0;
OpenGl_AABB aLftAABB;
OpenGl_AABB aRghAABB;
for (int anIndex = 0; anIndex < aSplit; ++anIndex)
{
aLftCount += aBins[anIndex].Count;
aLftAABB.Combine (aBins[anIndex].Volume);
}
for (int anIndex = aSplit; anIndex < THE_NUMBER_OF_BINS; ++anIndex) Standard_ASSERT_RETURN (anObjectIdx < myObjects.Size(),
{ "Error! Invalid leaf node in high-level BVH (contains out-of-range object)", Standard_False);
aRghCount += aBins[anIndex].Count;
aRghAABB.Combine (aBins[anIndex].Volume);
}
// Simple SAH evaluation OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
float aCost = ( aLftAABB.Area() / aNodeArea ) * aLftCount + myObjects.ChangeValue (anObjectIdx).operator->());
( aRghAABB.Area() / aNodeArea ) * aRghCount;
#ifdef BVH_DEBUG_OUTPUT // Note: We overwrite node info record to store parameters
std::cout << "\t\tBin " << aSplit << ", Cost = " << aCost << std::endl; // of bottom-level BVH and triangulation of OpenGL element
#endif
if (aCost <= aMinSplitCost) aBVH->NodeInfoBuffer().at (aNodeIdx) = BVH_Vec4i (
{ anObjectIdx + 1 /* to keep leaf flag */, aBVHNodesOffset, aVerticesOffset, aElementsOffset);
aMinSplitCost = aCost;
aMinSplitAxis = anAxis; aVerticesOffset += aTriangleSet->Vertices.size();
aMinSplitIndex = aSplit; aElementsOffset += aTriangleSet->Elements.size();
aMinSplitLftAABB = aLftAABB; aBVHNodesOffset += aTriangleSet->BVH()->Length();
aMinSplitRghAABB = aRghAABB;
aMinSplitLftCount = aLftCount;
aMinSplitRghCount = aRghCount;
}
}
} }
if (aMinSplitAxis == -1) return Standard_True;
{
// make outer (leaf) node
myTree.DataRcrdBuffer()[aTask.NodeToBuild].x() = 1;
return;
}
#ifdef BVH_DEBUG_OUTPUT
switch (aMinSplitAxis)
{
case 0:
std::cout << "\tSplit axis: X = " << aMinSplitIndex << std::endl;
break;
case 1:
std::cout << "\tSplit axis: Y = " << aMinSplitIndex << std::endl;
break;
case 2:
std::cout << "\tSplit axis: Z = " << aMinSplitIndex << std::endl;
break;
}
#endif
int aMiddle = SplitTriangles (theGeometry, aTask.BegTriangle, aTask.EndTriangle,
aNode, aMinSplitIndex - 1, aMinSplitAxis);
#ifdef BVH_DEBUG_OUTPUT
std::cout << "\tLeft child: [" << aTask.BegTriangle << ", "
<< aMiddle - 1 << "]" << std::endl;
std::cout << "\tRight child: [" << aMiddle << ", "
<< aTask.EndTriangle << "]" << std::endl;
#endif
#define BVH_SIDE_LFT 1
#define BVH_SIDE_RGH 2
// Setting up tasks for child nodes
for (int aSide = BVH_SIDE_LFT; aSide <= BVH_SIDE_RGH; ++aSide)
{
OpenGl_RTVec4f aMinPoint = (aSide == BVH_SIDE_LFT)
? aMinSplitLftAABB.CornerMin()
: aMinSplitRghAABB.CornerMin();
OpenGl_RTVec4f aMaxPoint = (aSide == BVH_SIDE_LFT)
? aMinSplitLftAABB.CornerMax()
: aMinSplitRghAABB.CornerMax();
int aBegTriangle = (aSide == BVH_SIDE_LFT)
? aTask.BegTriangle
: aMiddle;
int aEndTriangle = (aSide == BVH_SIDE_LFT)
? aMiddle - 1
: aTask.EndTriangle;
OpenGl_BVHNode aChild (aMinPoint, aMaxPoint, aBegTriangle, aEndTriangle);
aChild.SetLevel (aNode.Level() + 1);
// Check to see if child node must be split
const int aNbTriangles = (aSide == BVH_SIDE_LFT)
? aMinSplitLftCount
: aMinSplitRghCount;
const int isChildALeaf = (aNbTriangles <= THE_MAX_LEAF_TRIANGLES) || (aNode.Level() >= myMaxDepth);
if (isChildALeaf)
aChild.SetOuter();
else
aChild.SetInner();
const int aChildIndex = myTree.PushNode (aChild);
// Modify parent node
myTree.DataRcrdBuffer()[aTask.NodeToBuild].x() = 0; // inner node flag
if (aSide == BVH_SIDE_LFT)
myTree.DataRcrdBuffer()[aTask.NodeToBuild].y() = aChildIndex; // left child
else
myTree.DataRcrdBuffer()[aTask.NodeToBuild].z() = aChildIndex; // right child
// Make new building task
if (!isChildALeaf)
myNodeTasksQueue.push_back (OpenGl_BVHNodeTask (aChildIndex, aBegTriangle, aEndTriangle));
}
} }
// ======================================================================= // =======================================================================
// function : SplitTriangles // function : AccelerationOffset
// purpose : Splits node triangles into two intervals for child nodes // purpose : Returns offset of bottom-level BVH for given leaf node
// ======================================================================= // =======================================================================
int OpenGl_BinnedBVHBuilder::SplitTriangles (OpenGl_RaytraceScene& theGeometry, Standard_Integer OpenGl_RaytraceGeometry::AccelerationOffset (Standard_Integer theNodeIdx)
const int theBegTriangle,
const int theEndTriangle,
OpenGl_BVHNode& theNode,
int theBin,
const int theAxis)
{ {
int aLftIndex (theBegTriangle); const NCollection_Handle<BVH_Tree<Standard_ShortReal, 4> >& aBVH = BVH();
int aRghIndex (theEndTriangle);
const float aMin = theNode.MinPoint()[theAxis]; if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
const float aMax = theNode.MaxPoint()[theAxis]; return INVALID_OFFSET;
const float aStep = (aMax - aMin) / THE_NUMBER_OF_BINS; return aBVH->NodeInfoBuffer().at (theNodeIdx).y();
do
{
while ((int )floorf ((theGeometry.CenterAxis (aLftIndex, theAxis) - aMin) / aStep) <= theBin
&& aLftIndex < theEndTriangle)
{
++aLftIndex;
}
while ((int )floorf ((theGeometry.CenterAxis (aRghIndex, theAxis) - aMin) / aStep) > theBin
&& aRghIndex > theBegTriangle)
{
--aRghIndex;
}
if (aLftIndex <= aRghIndex)
{
if (aLftIndex != aRghIndex)
{
OpenGl_RTVec4i aLftTrg = theGeometry.Triangles[aLftIndex];
OpenGl_RTVec4i aRghTrg = theGeometry.Triangles[aRghIndex];
theGeometry.Triangles[aLftIndex] = aRghTrg;
theGeometry.Triangles[aRghIndex] = aLftTrg;
}
aLftIndex++; aRghIndex--;
}
} while (aLftIndex <= aRghIndex);
return aLftIndex;
} }
// ======================================================================= // =======================================================================
// function : GetSubVolumes // function : VerticesOffset
// purpose : Arranges node triangles into bins // purpose : Returns offset of triangulation vertices for given leaf node
// ======================================================================= // =======================================================================
void OpenGl_BinnedBVHBuilder::GetSubVolumes (OpenGl_RaytraceScene& theGeometry, Standard_Integer OpenGl_RaytraceGeometry::VerticesOffset (Standard_Integer theNodeIdx)
const OpenGl_BVHNode& theNode,
OpenGl_BinVector& theBins,
const int theAxis)
{ {
const float aMin = theNode.MinPoint()[theAxis]; const NCollection_Handle<BVH_Tree<Standard_ShortReal, 4> >& aBVH = BVH();
const float aMax = theNode.MaxPoint()[theAxis];
const float aStep = (aMax - aMin) / THE_NUMBER_OF_BINS; if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
return INVALID_OFFSET;
for (int aTri = theNode.BegTriangle(); aTri <= theNode.EndTriangle(); ++aTri) return aBVH->NodeInfoBuffer().at (theNodeIdx).z();
{ }
float aCenter = theGeometry.CenterAxis (aTri, theAxis);
int aBinIndex = (int )floorf ((aCenter - aMin) * ( 1.0f / aStep));
if (aBinIndex < 0)
{
aBinIndex = 0;
}
else if (aBinIndex >= THE_NUMBER_OF_BINS)
{
aBinIndex = THE_NUMBER_OF_BINS - 1;
}
theBins[aBinIndex].Count++; // =======================================================================
theBins[aBinIndex].Volume.Combine (theGeometry.Box (aTri)); // function : ElementsOffset
} // purpose : Returns offset of triangulation elements for given leaf node
// =======================================================================
Standard_Integer OpenGl_RaytraceGeometry::ElementsOffset (Standard_Integer theNodeIdx)
{
const NCollection_Handle<BVH_Tree<Standard_ShortReal, 4> >& aBVH = BVH();
if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
return INVALID_OFFSET;
return aBVH->NodeInfoBuffer().at (theNodeIdx).w();
}
// =======================================================================
// function : TriangleSet
// purpose : Returns triangulation data for given leaf node
// =======================================================================
OpenGl_TriangleSet* OpenGl_RaytraceGeometry::TriangleSet (Standard_Integer theNodeIdx)
{
const NCollection_Handle<BVH_Tree<Standard_ShortReal, 4> >& aBVH = BVH();
if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
return NULL;
if (aBVH->NodeInfoBuffer().at (theNodeIdx).x() > myObjects.Size())
return NULL;
return dynamic_cast<OpenGl_TriangleSet*> (myObjects.ChangeValue (
aBVH->NodeInfoBuffer().at (theNodeIdx).x() - 1).operator->());
} }
namespace OpenGl_Raytrace namespace OpenGl_Raytrace

358
src/OpenGl/OpenGl_SceneGeometry.hxx
View File

@ -18,9 +18,11 @@
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
#include <OpenGl_AABB.hxx> #include <BVH_Geometry.hxx>
#include <OpenGl_Structure.hxx> #include <BVH_Triangulation.hxx>
#include <NCollection_StdAllocator.hxx>
#include <OpenGl_PrimitiveArray.hxx> #include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_Structure.hxx>
namespace OpenGl_Raytrace namespace OpenGl_Raytrace
{ {
@ -40,25 +42,25 @@ class OpenGl_RaytraceMaterial
public: public:
//! Ambient reflection coefficient. //! Ambient reflection coefficient.
OpenGl_RTVec4f Ambient; BVH_Vec4f Ambient;
//! Diffuse reflection coefficient. //! Diffuse reflection coefficient.
OpenGl_RTVec4f Diffuse; BVH_Vec4f Diffuse;
//! Glossy reflection coefficient. //! Glossy reflection coefficient.
OpenGl_RTVec4f Specular; BVH_Vec4f Specular;
//! Material emission. //! Material emission.
OpenGl_RTVec4f Emission; BVH_Vec4f Emission;
//! Specular reflection coefficient. //! Specular reflection coefficient.
OpenGl_RTVec4f Reflection; BVH_Vec4f Reflection;
//! Specular refraction coefficient. //! Specular refraction coefficient.
OpenGl_RTVec4f Refraction; BVH_Vec4f Refraction;
//! Material transparency. //! Material transparency.
OpenGl_RTVec4f Transparency; BVH_Vec4f Transparency;
public: public:
@ -66,28 +68,31 @@ public:
OpenGl_RaytraceMaterial(); OpenGl_RaytraceMaterial();
//! Creates new material with specified properties. //! Creates new material with specified properties.
OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbient, OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
const OpenGl_RTVec4f& theDiffuse, const BVH_Vec4f& theDiffuse,
const OpenGl_RTVec4f& theSpecular); const BVH_Vec4f& theSpecular);
//! Creates new material with specified properties. //! Creates new material with specified properties.
OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbient, OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
const OpenGl_RTVec4f& theDiffuse, const BVH_Vec4f& theDiffuse,
const OpenGl_RTVec4f& theSpecular, const BVH_Vec4f& theSpecular,
const OpenGl_RTVec4f& theEmission, const BVH_Vec4f& theEmission,
const OpenGl_RTVec4f& theTranspar); const BVH_Vec4f& theTranspar);
//! Creates new material with specified properties. //! Creates new material with specified properties.
OpenGl_RaytraceMaterial (const OpenGl_RTVec4f& theAmbient, OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
const OpenGl_RTVec4f& theDiffuse, const BVH_Vec4f& theDiffuse,
const OpenGl_RTVec4f& theSpecular, const BVH_Vec4f& theSpecular,
const OpenGl_RTVec4f& theEmission, const BVH_Vec4f& theEmission,
const OpenGl_RTVec4f& theTranspar, const BVH_Vec4f& theTranspar,
const OpenGl_RTVec4f& theReflection, const BVH_Vec4f& theReflection,
const OpenGl_RTVec4f& theRefraction); const BVH_Vec4f& theRefraction);
//! Returns packed (serialized) representation of material. //! Returns packed (serialized) representation of material.
const float* Packed() { return reinterpret_cast<float*> (this); } const Standard_ShortReal* Packed()
{
return reinterpret_cast<Standard_ShortReal*> (this);
}
}; };
//! Stores properties of OpenGL light source. //! Stores properties of OpenGL light source.
@ -95,261 +100,110 @@ class OpenGl_RaytraceLight
{ {
public: public:
//! 'Ambient' intensity. //! Diffuse intensity (in terms of OpenGL).
OpenGl_RTVec4f Ambient; BVH_Vec4f Diffuse;
//! 'Diffuse' intensity.
OpenGl_RTVec4f Diffuse;
//! Position of light source (in terms of OpenGL). //! Position of light source (in terms of OpenGL).
OpenGl_RTVec4f Position; BVH_Vec4f Position;
public: public:
//! Creates new light source. //! Creates new light source.
OpenGl_RaytraceLight (const OpenGl_RTVec4f& theAmbient); OpenGl_RaytraceLight (const BVH_Vec4f& theDiffuse,
const BVH_Vec4f& thePosition);
//! Creates new light source.
OpenGl_RaytraceLight (const OpenGl_RTVec4f& theDiffuse,
const OpenGl_RTVec4f& thePosition);
//! Returns packed (serialized) representation of light source. //! Returns packed (serialized) representation of light source.
const float* Packed() { return reinterpret_cast<float*> (this); } const Standard_ShortReal* Packed()
{
return reinterpret_cast<Standard_ShortReal*> (this);
}
}; };
//! Stores scene geometry data. //! Triangulation of single OpenGL primitive array.
struct OpenGl_RaytraceScene class OpenGl_TriangleSet : public BVH_Triangulation<Standard_ShortReal, 4>
{ {
//! AABB of 3D scene. public:
OpenGl_AABB AABB;
//! Array of vertex normals. //! Array of vertex normals.
OpenGl_RTArray4f Normals; BVH_Array4f Normals;
//! Array of vertex coordinates. public:
OpenGl_RTArray4f Vertices;
//! Array of scene triangles. //! Creates new OpenGL element triangulation.
OpenGl_RTArray4i Triangles; OpenGl_TriangleSet()
{
//
}
//! Array of 'front' material properties. //! Releases resources of OpenGL element triangulation.
std::vector<OpenGl_RaytraceMaterial, ~OpenGl_TriangleSet()
NCollection_StdAllocator<OpenGl_RaytraceMaterial> > Materials; {
//
}
};
//! Stores geometry of ray-tracing scene.
class OpenGl_RaytraceGeometry : public BVH_Geometry<Standard_ShortReal, 4>
{
public:
//! Value of invalid offset to return in case of errors.
static const Standard_Integer INVALID_OFFSET = -1;
public:
//! Array of properties of light sources. //! Array of properties of light sources.
std::vector<OpenGl_RaytraceLight, std::vector<OpenGl_RaytraceLight,
NCollection_StdAllocator<OpenGl_RaytraceLight> > LightSources; NCollection_StdAllocator<OpenGl_RaytraceLight> > Sources;
//! Clears all scene geometry and material data. //! Array of 'front' material properties.
std::vector<OpenGl_RaytraceMaterial,
NCollection_StdAllocator<OpenGl_RaytraceMaterial> > Materials;
//! Global ambient from all light sources.
BVH_Vec4f GlobalAmbient;
public:
//! Creates uninitialized ray-tracing geometry.
OpenGl_RaytraceGeometry()
{
//
}
//! Releases resources of ray-tracing geometry.
~OpenGl_RaytraceGeometry()
{
//
}
//! Clears ray-tracing geometry.
void Clear(); void Clear();
//! Returns AABB of specified triangle.
OpenGl_AABB Box (const int theTriangle) const;
//! Returns centroid of specified triangle.
OpenGl_RTVec4f Center (const int theTriangle) const;
//! Returns centroid coordinate for specified axis.
float CenterAxis (const int theTriangle, const int theAxis) const;
};
//! Stores parameters of BVH tree node.
class OpenGl_BVHNode
{
friend class OpenGl_BVH;
public: public:
//! Creates new empty BVH node. //! Performs post-processing of high-level scene BVH.
OpenGl_BVHNode(); Standard_Boolean ProcessAcceleration();
//! Creates new BVH node with specified data. //! Returns offset of bottom-level BVH for given leaf node.
OpenGl_BVHNode (const OpenGl_RTVec4f& theMinPoint, //! If the node index is not valid the function returns -1.
const OpenGl_RTVec4f& theMaxPoint, //! @note Can be used after processing acceleration structure.
const OpenGl_RTVec4i& theDataRcrd); Standard_Integer AccelerationOffset (Standard_Integer theNodeIdx);
//! Creates new leaf BVH node with specified data. //! Returns offset of triangulation vertices for given leaf node.
OpenGl_BVHNode (const OpenGl_RTVec4f& theMinPoint, //! If the node index is not valid the function returns -1.
const OpenGl_RTVec4f& theMaxPoint, //! @note Can be used after processing acceleration structure.
const int theBegTriangle, Standard_Integer VerticesOffset (Standard_Integer theNodeIdx);
const int theEndTriangle);
//! Creates new leaf BVH node with specified data. //! Returns offset of triangulation elements for given leaf node.
OpenGl_BVHNode (const OpenGl_AABB& theAABB, //! If the node index is not valid the function returns -1.
const int theBegTriangle, //! @note Can be used after processing acceleration structure.
const int theEndTriangle); Standard_Integer ElementsOffset (Standard_Integer theNodeIdx);
//! Returns minimum point of node's AABB. //! Returns triangulation data for given leaf node.
OpenGl_RTVec4f& MinPoint() { return myMinPoint; } //! If the node index is not valid the function returns NULL.
//! Returns maximum point of node's AABB. //! @note Can be used after processing acceleration structure.
OpenGl_RTVec4f& MaxPoint() { return myMaxPoint; } OpenGl_TriangleSet* TriangleSet (Standard_Integer theNodeIdx);
//! Returns minimum point of node's AABB.
const OpenGl_RTVec4f& MinPoint() const { return myMinPoint; }
//! Returns maximum point of node's AABB.
const OpenGl_RTVec4f& MaxPoint() const { return myMaxPoint; }
//! Returns index of left child of inner node.
int LeftChild() const { return myDataRcrd.y(); }
//! Sets index of left child of inner node.
void SetLeftChild (int theChild) { myDataRcrd.y() = theChild; }
//! Returns index of right child of inner node.
int RightChild() const { return myDataRcrd.z(); }
//! Sets index of right child of inner node.
void SetRightChild (int theChild) { myDataRcrd.z() = theChild; }
//! Returns index of begin triangle of leaf node.
int BegTriangle() const { return myDataRcrd.y(); }
//! Sets index of begin triangle of leaf node.
void SetBegTriangle (int theIndex) { myDataRcrd.y() = theIndex; }
//! Returns index of end triangle of leaf node.
int EndTriangle() const { return myDataRcrd.z(); }
//! Sets index of end triangle of leaf node.
void SetEndTriangle (int theIndex) { myDataRcrd.z() = theIndex; }
//! Returns level of the node in BVH tree.
int Level() const { return myDataRcrd.w(); }
//! Sets level of the node in BVH tree.
void SetLevel (int theLevel) { myDataRcrd.w() = theLevel; }
//! Is node a leaf (outer)?
bool IsOuter() const { return myDataRcrd.x() == 1; }
//! Sets node type to 'outer'.
void SetOuter() { myDataRcrd.x() = 1; }
//! Sets node type to 'inner'.
void SetInner() { myDataRcrd.x() = 0; }
private:
//! Minimum point of node's bounding box.
OpenGl_RTVec4f myMinPoint;
//! Maximum point of node's bounding box.
OpenGl_RTVec4f myMaxPoint;
//! Data vector (stores data fields of the node).
OpenGl_RTVec4i myDataRcrd;
};
//! Stores parameters of BVH tree.
class OpenGl_BVH
{
public:
//! Removes all tree nodes.
void CleanUp();
//! Adds new node to the tree.
int PushNode (const OpenGl_BVHNode& theNode);
//! Returns node with specified index.
OpenGl_BVHNode Node (const int theIndex) const;
//! Replaces node with specified index by the new one.
void SetNode (const int theIndex, const OpenGl_BVHNode& theNode);
//! Returns array of node min points.
OpenGl_RTArray4f& MinPointBuffer() { return myMinPointBuffer; }
//! Returns array of node max points.
OpenGl_RTArray4f& MaxPointBuffer() { return myMaxPointBuffer; }
//! Returns array of node data records.
OpenGl_RTArray4i& DataRcrdBuffer() { return myDataRcrdBuffer; }
private:
//! Array of min points of BVH nodes.
OpenGl_RTArray4f myMinPointBuffer;
//! Array of max points of BVH nodes.
OpenGl_RTArray4f myMaxPointBuffer;
//! Array of data vectors of BVH nodes.
OpenGl_RTArray4i myDataRcrdBuffer;
};
//! Stores parameters of single node bin (slice of AABB).
struct OpenGl_BVHBin
{
//! Creates new node bin.
OpenGl_BVHBin(): Count (0) { }
//! Number of primitives in the bin.
int Count;
//! AABB of the bin.
OpenGl_AABB Volume;
};
//! Node building task.
struct OpenGl_BVHNodeTask
{
//! Creates new node building task.
OpenGl_BVHNodeTask();
//! Creates new node building task.
OpenGl_BVHNodeTask (const int theNodeToBuild,
const int theBegTriangle,
const int theEndTriangle);
//! Index of building tree node.
int NodeToBuild;
//! Index of start node triangle.
int BegTriangle;
//! Index of final node triangle.
int EndTriangle;
};
//! The array of bins of BVH tree node.
typedef std::vector<OpenGl_BVHBin,
NCollection_StdAllocator<OpenGl_BVHBin> > OpenGl_BinVector;
//! Binned SAH-based BVH builder.
class OpenGl_BinnedBVHBuilder
{
public:
//! Creates new binned BVH builder.
OpenGl_BinnedBVHBuilder();
//! Releases binned BVH builder.
~OpenGl_BinnedBVHBuilder();
//! Builds BVH tree using binned SAH algorithm.
void Build (OpenGl_RaytraceScene& theGeometry, const float theEpsilon = 1e-3f);
//! Sets maximum tree depth.
void SetMaxDepth (const int theMaxDepth);
//! Clears previously constructed BVH tree.
void CleanUp();
//! Return constructed BVH tree.
OpenGl_BVH& Tree() { return myTree; }
private:
//! Builds node using task info.
void BuildNode (OpenGl_RaytraceScene& theGeometry, const int theTask);
//! Arranges node triangles into bins.
void GetSubVolumes (OpenGl_RaytraceScene& theGeometry, const OpenGl_BVHNode& theNode,
OpenGl_BinVector& theBins, const int theAxis);
//! Splits node triangles into two intervals for child nodes.
int SplitTriangles (OpenGl_RaytraceScene& theGeometry, const int theFirst, const int theLast,
OpenGl_BVHNode& theNode, int theBin, const int theAxis);
private:
//! Queue of node building tasks.
std::vector<OpenGl_BVHNodeTask> myNodeTasksQueue;
//! Builded BVH tree.
OpenGl_BVH myTree;
//! Maximum depth of BVH tree.
int myMaxDepth;
}; };
#endif #endif

100
src/OpenGl/OpenGl_Workspace.hxx
View File

@ -275,42 +275,42 @@ protected: //! @name methods related to ray-tracing
//! Updates environment map for ray-tracing. //! Updates environment map for ray-tracing.
Standard_Boolean UpdateRaytraceEnvironmentMap(); Standard_Boolean UpdateRaytraceEnvironmentMap();
//! Adds OpenGL structure to ray-traced scene geometry. //! Adds OpenGL structure to ray-traced scene geometry.
Standard_Boolean AddRaytraceStructure (const OpenGl_Structure* theStruct, Standard_Boolean AddRaytraceStructure (const OpenGl_Structure* theStructure,
const float* theTrans, std::set<const OpenGl_Structure*>& theElements); const Standard_ShortReal* theTransform, std::set<const OpenGl_Structure*>& theElements);
//! Adds OpenGL primitive array to ray-traced scene geometry. //! Adds OpenGL primitive array to ray-traced scene geometry.
Standard_Boolean AddRaytracePrimitiveArray ( OpenGl_TriangleSet* AddRaytracePrimitiveArray (
const CALL_DEF_PARRAY* theArray, int theMatID, const float* theTrans); const CALL_DEF_PARRAY* theArray, int theMatID, const Standard_ShortReal* theTrans);
//! Adds vertex indices from OpenGL primitive array to ray-traced scene geometry. //! Adds vertex indices from OpenGL primitive array to ray-traced scene geometry.
Standard_Boolean AddRaytraceVertexIndices (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytraceVertexIndices (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Adds OpenGL triangle array to ray-traced scene geometry. //! Adds OpenGL triangle array to ray-traced scene geometry.
Standard_Boolean AddRaytraceTriangleArray (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytraceTriangleArray (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Adds OpenGL triangle fan array to ray-traced scene geometry. //! Adds OpenGL triangle fan array to ray-traced scene geometry.
Standard_Boolean AddRaytraceTriangleFanArray (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytraceTriangleFanArray (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Adds OpenGL triangle fan array to ray-traced scene geometry. //! Adds OpenGL triangle strip array to ray-traced scene geometry.
Standard_Boolean AddRaytraceTriangleStripArray (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytraceTriangleStripArray (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Adds OpenGL quadrangle array to ray-traced scene geometry. //! Adds OpenGL quadrangle array to ray-traced scene geometry.
Standard_Boolean AddRaytraceQuadrangleArray (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytraceQuadrangleArray (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Adds OpenGL quadrangle strip array to ray-traced scene geometry. //! Adds OpenGL quadrangle strip array to ray-traced scene geometry.
Standard_Boolean AddRaytraceQuadrangleStripArray (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytraceQuadrangleStripArray (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Adds OpenGL polygon array to ray-traced scene geometry. //! Adds OpenGL polygon array to ray-traced scene geometry.
Standard_Boolean AddRaytracePolygonArray (const CALL_DEF_PARRAY* theArray, Standard_Boolean AddRaytracePolygonArray (OpenGl_TriangleSet* theSet,
int theFirstVert, int theVertOffset, int theVertNum, int theMatID); const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Initializes OpenCL resources. //! Initializes OpenCL resources.
Standard_Boolean InitOpenCL(); Standard_Boolean InitOpenCL();
@ -325,12 +325,19 @@ protected: //! @name methods related to ray-tracing
Standard_Boolean WriteRaytraceSceneToDevice(); Standard_Boolean WriteRaytraceSceneToDevice();
//! Runs OpenCL ray-tracing kernels. //! Runs OpenCL ray-tracing kernels.
Standard_Boolean RunRaytraceOpenCLKernels (const Graphic3d_CView& theCView, Standard_Boolean RunRaytraceOpenCLKernelsOld (const Graphic3d_CView& theCView,
const GLfloat theOrigins[16], const GLfloat theOrigins[16],
const GLfloat theDirects[16], const GLfloat theDirects[16],
const int theSizeX, const int theSizeX,
const int theSizeY); const int theSizeY);
//! Launches OpenCL ray-tracing kernels.
Standard_Boolean RunRaytraceOpenCLKernels (const Graphic3d_CView& theCView,
const Standard_ShortReal theOrigins[16],
const Standard_ShortReal theDirects[16],
const Standard_Integer theSizeX,
const Standard_Integer theSizeY);
//! Redraws the window using OpenCL ray tracing. //! Redraws the window using OpenCL ray tracing.
Standard_Boolean Raytrace (const Graphic3d_CView& theCView, Standard_Boolean Raytrace (const Graphic3d_CView& theCView,
const int theSizeX, const int theSizeY, const Tint theToSwap); const int theSizeX, const int theSizeY, const Tint theToSwap);
@ -346,21 +353,19 @@ protected: //! @name fields related to ray-tracing
Standard_Boolean myIsRaytraceDataValid; Standard_Boolean myIsRaytraceDataValid;
//! Is geometry data musty be updated? //! Is geometry data musty be updated?
Standard_Boolean myToUpdateRaytraceData; Standard_Boolean myToUpdateRaytraceData;
//! 3D scene geometry data for ray-tracing. //! 3D scene geometry data for ray-tracing.
OpenGl_RaytraceScene myRaytraceSceneData; OpenGl_RaytraceGeometry myRaytraceGeometry;
//! Radius of bounding sphere of the scene. //! Radius of bounding sphere of the scene.
float myRaytraceSceneRadius; Standard_ShortReal myRaytraceSceneRadius;
//! Scene epsilon to prevent self-intersections. //! Scene epsilon to prevent self-intersections.
float myRaytraceSceneEpsilon; Standard_ShortReal myRaytraceSceneEpsilon;
//! Binned SAH-based BVH builder.
OpenGl_BinnedBVHBuilder myBVHBuilder;
//! OpenCL context. //! OpenCL context.
cl_context myComputeContext; cl_context myComputeContext;
//! OpenCL command queue. //! OpenCL command queue.
cl_command_queue myRaytraceQueue; cl_command_queue myComputeQueue;
//! OpenCL computing program. //! OpenCL computing program.
cl_program myRaytraceProgram; cl_program myRaytraceProgram;
//! OpenCL ray-tracing render kernel. //! OpenCL ray-tracing render kernel.
@ -380,33 +385,38 @@ protected: //! @name fields related to ray-tracing
//! OpenGL texture to store anti-aliasing result. //! OpenGL texture to store anti-aliasing result.
Handle(OpenGl_Texture) myRaytraceOutputTextureAA; Handle(OpenGl_Texture) myRaytraceOutputTextureAA;
//! OpenCL buffer of vertex normals.
cl_mem myRaytraceNormalBuffer;
//! OpenCL buffer of vertex coordinates.
cl_mem myRaytraceVertexBuffer;
//! OpenCL buffer of indices of triangle vertices.
cl_mem myRaytraceTriangleBuffer;
//! OpenCL buffer of minimum points of BVH nodes.
cl_mem myRaytraceNodeMinPointBuffer;
//! OpenCL buffer of maximum points of BVH nodes.
cl_mem myRaytraceNodeMaxPointBuffer;
//! OpenCL buffer of data records of BVH nodes.
cl_mem myRaytraceNodeDataRcrdBuffer;
//! OpenCL buffer of material properties. //! OpenCL buffer of material properties.
cl_mem myRaytraceMaterialBuffer; cl_mem myRaytraceMaterialBuffer;
//! OpenCL buffer of light source properties. //! OpenCL buffer of light source properties.
cl_mem myRaytraceLightSourceBuffer; cl_mem myRaytraceLightSourceBuffer;
//! OpenCL buffer of vertex coords.
cl_mem myGeometryVertexBuffer;
//! OpenCL buffer of vertex normals.
cl_mem myGeometryNormalBuffer;
//! OpenCL buffer of triangle indices.
cl_mem myGeometryTriangBuffer;
//! OpenCL buffer of data records of high-level BVH nodes.
cl_mem mySceneNodeInfoBuffer;
//! OpenCL buffer of minimum points of high-level BVH nodes.
cl_mem mySceneMinPointBuffer;
//! OpenCL buffer of maximum points of high-level BVH nodes.
cl_mem mySceneMaxPointBuffer;
//! OpenCL buffer of data records of bottom-level BVH nodes.
cl_mem myObjectNodeInfoBuffer;
//! OpenCL buffer of minimum points of bottom-level BVH nodes.
cl_mem myObjectMinPointBuffer;
//! OpenCL buffer of maximum points of bottom-level BVH nodes.
cl_mem myObjectMaxPointBuffer;
//! State of OpenGL view. //! State of OpenGL view.
Standard_Size myViewModificationStatus; Standard_Size myViewModificationStatus;
//! State of OpenGL layer list. //! State of OpenGL layer list.
Standard_Size myLayersModificationStatus; Standard_Size myLayersModificationStatus;
//! State of OpenGL elements reflected to ray-tracing. //! State of OpenGL structures reflected to ray-tracing.
std::map<const OpenGl_Structure*, Standard_Size> myStructureStates; std::map<const OpenGl_Structure*, Standard_Size> myStructureStates;
#endif // HAVE_OPENCL #endif // HAVE_OPENCL

1494
src/OpenGl/OpenGl_Workspace_Raytrace.cxx
View File

File diff suppressed because it is too large Load Diff

1
tests/v3d/raytrace/bug24130
View File

@ -18,6 +18,7 @@ restore $aShape2 s2
vdisplay s1 s2 vdisplay s1 s2
vsetmaterial s1 Silver vsetmaterial s1 Silver
vsetmaterial s2 Pewter vsetmaterial s2 Pewter
vlight change 0 pos -1 1 1
vfit vfit
# activate ray-tracing # activate ray-tracing