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

0024739: TKOpenGl - port ray-tracing from OpenCL to GLSL for better integration and portability

Browse Source 
RayTracing - disable reflections by default
Fix possible compilation issue on Mac OS X.
This commit is contained in:
dbp 2014-04-04 14:14:02 +04:00 committed by apn
parent 54e37688ef
commit fc73a20256
39 changed files with 2399 additions and 2676 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
samples/tcl/raytrace.tcl
View File

@ -30,10 +30,8 @@ vsetcolorbg 255 255 255
vfit
# set ray tracing
if { [regexp {HAVE_OPENCL} [dversion]] } {
puts "Trying raytrace mode..."
if { ! [catch {vraytrace 1}] } {
vtextureenv on 1
vsetraytracemode shad=1 refl=1 aa=1
}
puts "Trying raytrace mode..."
if { ! [catch {vraytrace 1}] } {
vtextureenv on 1
vsetraytracemode shad=1 refl=1 aa=1
}

4
src/BVH/BVH_BinnedBuilder.lxx
View File

@ -282,6 +282,10 @@ void BVH_BinnedBuilder<T, N, Bins>::BuildNode (BVH_Set<T, N>* theSet,
|| theBVH->Level (aChildIndex) >= BVH_Builder<T, N>::myMaxTreeDepth;
if (!isLeaf)
{
BVH_Builder<T, N>::myTasksQueue.Append (aChildIndex);
}
BVH_Builder<T, N>::UpdateDepth (theBVH, theBVH->Level (aChildIndex));
}
}

10
src/BVH/BVH_Builder.hxx
View File

@ -54,6 +54,16 @@ protected:
BVH_Tree<T, N>* theBVH,
const Standard_Integer theTask);
//! Updates depth of constructed BVH tree.
void UpdateDepth (BVH_Tree<T, N>* theBVH,
const Standard_Integer theLevel)
{
if (theLevel > theBVH->myDepth)
{
theBVH->myDepth = theLevel;
}
}
protected:
Standard_Integer myMaxTreeDepth; //!< Maximum depth of constructed BVH

2
src/BVH/BVH_SweepPlaneBuilder.lxx
View File

@ -184,5 +184,7 @@ void BVH_SweepPlaneBuilder<T, N>::BuildNode (BVH_Set<T, N>* theSet,
{
BVH_Builder<T, N>::myTasksQueue.Append (aChildIndex);
}
BVH_Builder<T, N>::UpdateDepth (theBVH, theBVH->Level (aChildIndex));
}
}

19
src/BVH/BVH_Tree.hxx
View File

@ -20,6 +20,8 @@
#include <BVH_Box.hxx>
template<class T, int N> class BVH_Builder;
//! Stores parameters of bounding volume hierarchy (BVH).
//! Bounding volume hierarchy (BVH) organizes geometric objects in
//! the tree based on spatial relationships. Each node in the tree
@ -31,12 +33,20 @@
template<class T, int N>
class BVH_Tree
{
friend class BVH_Builder<T, N>;
public:
typedef typename BVH_Box<T, N>::BVH_VecNt BVH_VecNt;
public:
//! Creates new empty BVH tree.
BVH_Tree() : myDepth (0)
{
//
}
//! Returns minimum point of the given node.
BVH_VecNt& MinPoint (const Standard_Integer theNodeIndex)
{
@ -151,6 +161,12 @@ public:
return BVHTools::ArrayOp<Standard_Integer, 4>::Size (myNodeInfoBuffer);
}
//! Returns depth of BVH tree from last build.
Standard_Integer Depth() const
{
return myDepth;
}
public:
//! Removes all BVH nodes.
@ -232,6 +248,9 @@ protected:
//! Array of node data records.
BVH_Array4i myNodeInfoBuffer;
//! Depth of constructed tree.
Standard_Integer myDepth;
};
#include <BVH_Tree.lxx>

2
src/BVH/BVH_Tree.lxx
View File

@ -20,6 +20,8 @@
template<class T, int N>
void BVH_Tree<T, N>::Clear()
{
myDepth = 0;
BVHTools::ArrayOp<T, N>::Clear (myMinPointBuffer);
BVHTools::ArrayOp<T, N>::Clear (myMaxPointBuffer);

2
src/Graphic3d/Graphic3d_CView.hxx
View File

@ -100,7 +100,7 @@ public:
WasRedrawnGL (0),
IsRaytracing (0),
IsShadowsEnabled (1),
IsReflectionsEnabled (1),
IsReflectionsEnabled (0),
IsAntialiasingEnabled (0)
{
memset(&DefWindow,0,sizeof(DefWindow));

1
src/OpenGl/EXTERNLIB
View File

@ -6,7 +6,6 @@ CSF_objc
CSF_Appkit
CSF_IOKit
CSF_OpenGlLibs
CSF_OPENCL
CSF_AviLibs
CSF_FREETYPE
CSF_GL2PS

2
src/OpenGl/FILES
View File

@ -140,10 +140,8 @@ OpenGl_ShaderStates.cxx
Handle_OpenGl_ShaderObject.hxx
Handle_OpenGl_ShaderProgram.hxx
Handle_OpenGl_ShaderManager.hxx
OpenGl_Cl.hxx
OpenGl_SceneGeometry.hxx
OpenGl_SceneGeometry.cxx
OpenGl_RaytraceSource.cxx
OpenGl_Workspace_Raytrace.cxx
OpenGl_Flipper.hxx
OpenGl_Flipper.cxx

29
src/OpenGl/OpenGl_Cl.hxx
View File

@ -1,29 +0,0 @@
// Created on: 2013-10-15
// Created by: Denis BOGOLEPOV
// Copyright (c) 2013-2014 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 License 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_Cl_H__
#define _OpenGl_Cl_H__
// cl_gl.h includes OpenGL headers - make sure our stuff is included in right order
#include <OpenGl_GlCore20.hxx>
#if defined(__APPLE__) || defined(__MACOSX)
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#include <CL/cl_gl.h>
#endif
#endif // _OpenGl_Cl_H__

28
src/OpenGl/OpenGl_GraphicDriver.cxx
View File

@ -171,34 +171,6 @@ Standard_Boolean OpenGl_GraphicDriver::SetImmediateModeDrawToFront (const Graphi
return Standard_False;
}
// =======================================================================
// function : GetOpenClDeviceInfo
// purpose : Returns information about device used for computations
// =======================================================================
#ifndef HAVE_OPENCL
Standard_Boolean OpenGl_GraphicDriver::GetOpenClDeviceInfo (const Graphic3d_CView&,
NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>&)
{
return Standard_False;
}
#else
Standard_Boolean OpenGl_GraphicDriver::GetOpenClDeviceInfo (const Graphic3d_CView& theCView,
NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>& theInfo)
{
if (theCView.ViewId == -1 || theCView.ptrView == NULL)
{
return Standard_False;
}
return reinterpret_cast<const OpenGl_CView*> (theCView.ptrView)->WS->GetOpenClDeviceInfo (theInfo);
}
#endif
// =======================================================================
// function : DisplayImmediateStructure
// purpose :

4
src/OpenGl/OpenGl_GraphicDriver.hxx
View File

@ -308,10 +308,6 @@ public:
Standard_EXPORT OpenGl_UserDrawCallback_t& UserDrawCallback();
public:
//! Returns information about OpenCL device used for computations.
Standard_EXPORT Standard_Boolean GetOpenClDeviceInfo (const Graphic3d_CView& theCView,
NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>& theInfo);
//! Method to retrieve valid GL context.
//! Could return NULL-handle if no window created by this driver.

8
src/OpenGl/OpenGl_Group.cxx
View File

@ -13,10 +13,6 @@
// 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
#include <OpenGl_Group.hxx>
#include <OpenGl_GraphicDriver.hxx>
@ -118,7 +114,6 @@ void OpenGl_Group::UpdateAspectFace (const Standard_Boolean theIsGlobal)
AddElement (anAspectFace);
}
#ifdef HAVE_OPENCL
if (myIsRaytracable)
{
++myModificationState;
@ -128,7 +123,6 @@ void OpenGl_Group::UpdateAspectFace (const Standard_Boolean theIsGlobal)
aStruct->UpdateStateWithAncestorStructures();
}
}
#endif
}
// =======================================================================
@ -300,7 +294,6 @@ void OpenGl_Group::AddElement (OpenGl_Element* theElem)
(myLast? myLast->next : myFirst) = aNode;
myLast = aNode;
#ifdef HAVE_OPENCL
if (OpenGl_Raytrace::IsRaytracedElement (aNode))
{
myModificationState++;
@ -313,7 +306,6 @@ void OpenGl_Group::AddElement (OpenGl_Element* theElem)
aStruct->SetRaytracableWithAncestorStructures();
}
}
#endif
}
// =======================================================================

8
src/OpenGl/OpenGl_LayerList.cxx
View File

@ -13,10 +13,6 @@
// 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
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_LayerList.hxx>
@ -176,12 +172,10 @@ void OpenGl_LayerList::RemoveStructure (const OpenGl_Structure *theStructure,
{
myNbStructures--;
#ifdef HAVE_OPENCL
if (theStructure->IsRaytracable())
{
myModificationState++;
}
#endif
return;
}
@ -199,12 +193,10 @@ void OpenGl_LayerList::RemoveStructure (const OpenGl_Structure *theStructure,
{
myNbStructures--;
#ifdef HAVE_OPENCL
if (theStructure->IsRaytracable())
{
myModificationState++;
}
#endif
return;
}

6
src/OpenGl/OpenGl_LayerList.hxx
View File

@ -77,14 +77,10 @@ class OpenGl_LayerList
//! Returns the set of OpenGL Z-layers.
const OpenGl_SequenceOfLayers& Layers() const { return myLayers; }
#ifdef HAVE_OPENCL
//! Returns structure modification state (for ray-tracing).
Standard_Size ModificationState() const { return myModificationState; }
#endif
private:
//! Get default layer
@ -98,9 +94,7 @@ class OpenGl_LayerList
Standard_Integer myNbPriorities;
Standard_Integer myNbStructures;
#ifdef HAVE_OPENCL
mutable Standard_Size myModificationState;
#endif
public:
DEFINE_STANDARD_ALLOC

1163
src/OpenGl/OpenGl_RaytraceSource.cxx
View File

File diff suppressed because it is too large Load Diff

14
src/OpenGl/OpenGl_SceneGeometry.cxx
View File

@ -13,12 +13,6 @@
// 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_Assert.hxx>
#ifdef HAVE_TBB
@ -206,6 +200,8 @@ Standard_Boolean OpenGl_RaytraceGeometry::ProcessAcceleration()
OpenGL_BVHParallelBuilder (this));
#endif
myBottomLevelTreeDepth = 0;
for (Standard_Integer anObjectIdx = 0; anObjectIdx < Size(); ++anObjectIdx)
{
OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
@ -216,6 +212,8 @@ Standard_Boolean OpenGl_RaytraceGeometry::ProcessAcceleration()
Standard_ASSERT_RETURN (!aTriangleSet->BVH().IsNull(),
"Error! Failed to update bottom-level BVH of OpenGL element", Standard_False);
myBottomLevelTreeDepth = Max (myBottomLevelTreeDepth, aTriangleSet->BVH()->Depth());
}
#ifdef BVH_PRINT_INFO
@ -242,6 +240,8 @@ Standard_Boolean OpenGl_RaytraceGeometry::ProcessAcceleration()
Standard_ASSERT_RETURN (!aBVH.IsNull(),
"Error! Failed to update high-level BVH of ray-tracing scene", Standard_False);
myHighLevelTreeDepth = aBVH->Depth();
Standard_Integer aVerticesOffset = 0;
Standard_Integer aElementsOffset = 0;
Standard_Integer aBVHNodesOffset = 0;
@ -387,5 +387,3 @@ namespace OpenGl_Raytrace
return Standard_False;
}
}
#endif

30
src/OpenGl/OpenGl_SceneGeometry.hxx
View File

@ -16,8 +16,6 @@
#ifndef _OpenGl_SceneGeometry_Header
#define _OpenGl_SceneGeometry_Header
#ifdef HAVE_OPENCL
#include <BVH_Geometry.hxx>
#include <BVH_Triangulation.hxx>
#include <NCollection_StdAllocator.hxx>
@ -124,13 +122,13 @@ class OpenGl_TriangleSet : public BVH_Triangulation<Standard_ShortReal, 4>
{
public:
//! Array of vertex normals.
BVH_Array4f Normals;
BVH_Array4f Normals; //!< Array of vertex normals
public:
//! Creates new OpenGL element triangulation.
OpenGl_TriangleSet()
: BVH_Triangulation<Standard_ShortReal, 4>()
{
//
}
@ -161,12 +159,15 @@ public:
NCollection_StdAllocator<OpenGl_RaytraceMaterial> > Materials;
//! Global ambient from all light sources.
BVH_Vec4f GlobalAmbient;
BVH_Vec4f Ambient;
public:
//! Creates uninitialized ray-tracing geometry.
OpenGl_RaytraceGeometry()
: BVH_Geometry<Standard_ShortReal, 4>(),
myHighLevelTreeDepth (0),
myBottomLevelTreeDepth (0)
{
//
}
@ -204,7 +205,24 @@ public:
//! If the node index is not valid the function returns NULL.
//! @note Can be used after processing acceleration structure.
OpenGl_TriangleSet* TriangleSet (Standard_Integer theNodeIdx);
//! Returns depth of high-level scene BVH from last build.
Standard_Integer HighLevelTreeDepth() const
{
return myHighLevelTreeDepth;
}
//! Returns maximum depth of bottom-level scene BVHs from last build.
Standard_Integer BottomLevelTreeDepth() const
{
return myBottomLevelTreeDepth;
}
protected:
Standard_Integer myHighLevelTreeDepth; //!< Depth of high-level scene BVH from last build
Standard_Integer myBottomLevelTreeDepth; //!< Maximum depth of bottom-level scene BVHs from last build
};
#endif
#endif

141
src/OpenGl/OpenGl_ShaderProgram.cxx
View File

@ -374,17 +374,19 @@ Standard_Boolean OpenGl_ShaderProgram::Link (const Handle(OpenGl_Context)& theCt
return Standard_False;
}
theCtx->core20->glLinkProgram (myProgramID);
GLint aStatus = GL_FALSE;
theCtx->core20->glLinkProgram (myProgramID);
theCtx->core20->glGetProgramiv (myProgramID, GL_LINK_STATUS, &aStatus);
if (aStatus == GL_FALSE)
{
return Standard_False;
}
for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
{
myStateLocations[aVar] = GetUniformLocation (theCtx, PredefinedKeywords[aVar]);
}
return aStatus != GL_FALSE;
return Standard_True;
}
// =======================================================================
@ -644,6 +646,130 @@ Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context
return Standard_True;
}
// =======================================================================
// function : SetAttributeName
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttributeName (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const GLchar* theName)
{
theCtx->core20fwd->glBindAttribLocation (myProgramID, theIndex, theName);
return Standard_True;
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
GLfloat theValue)
{
return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
GLfloat theValue)
{
if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
{
return Standard_False;
}
theCtx->core20fwd->glVertexAttrib1f (theIndex, theValue);
return Standard_True;
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const OpenGl_Vec2& theValue)
{
return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const OpenGl_Vec2& theValue)
{
if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
{
return Standard_False;
}
theCtx->core20fwd->glVertexAttrib2fv (theIndex, theValue);
return Standard_True;
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const OpenGl_Vec3& theValue)
{
return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const OpenGl_Vec3& theValue)
{
if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
{
return Standard_False;
}
theCtx->core20fwd->glVertexAttrib3fv (theIndex, theValue);
return Standard_True;
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const OpenGl_Vec4& theValue)
{
return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
}
// =======================================================================
// function : SetAttribute
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const OpenGl_Vec4& theValue)
{
if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
{
return Standard_False;
}
theCtx->core20fwd->glVertexAttrib4fv (theIndex, theValue);
return Standard_True;
}
// =======================================================================
// function : SetUniform
// purpose : Specifies the value of the integer uniform variable
@ -1131,8 +1257,11 @@ void OpenGl_ShaderProgram::Release (const OpenGl_Context* theCtx)
for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
{
anIter.ChangeValue()->Release (theCtx);
anIter.ChangeValue().Nullify();
if (!anIter.Value().IsNull())
{
anIter.ChangeValue()->Release (theCtx);
anIter.ChangeValue().Nullify();
}
}
if (theCtx->core20 != NULL

48
src/OpenGl/OpenGl_ShaderProgram.hxx
View File

@ -128,6 +128,7 @@ const int MaxStateTypes = 6;
//! Wrapper for OpenGL program object.
class OpenGl_ShaderProgram : public OpenGl_Resource
{
friend class OpenGl_Workspace;
public:
@ -260,6 +261,53 @@ public:
GLint theIndex,
OpenGl_Vec4& theValue) const;
public:
//! Wrapper for glBindAttribLocation()
Standard_EXPORT Standard_Boolean SetAttributeName (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const GLchar* theName);
//! Wrapper for glVertexAttrib1f()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
GLfloat theValue);
//! Wrapper for glVertexAttrib1f()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
GLfloat theValue);
//! Wrapper for glVertexAttrib2fv()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const OpenGl_Vec2& theValue);
//! Wrapper for glVertexAttrib2fv()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const OpenGl_Vec2& theValue);
//! Wrapper for glVertexAttrib3fv()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const OpenGl_Vec3& theValue);
//! Wrapper for glVertexAttrib3fv()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const OpenGl_Vec3& theValue);
//! Wrapper for glVertexAttrib4fv()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const OpenGl_Vec4& theValue);
//! Wrapper for glVertexAttrib4fv()
Standard_EXPORT Standard_Boolean SetAttribute (const Handle(OpenGl_Context)& theCtx,
GLint theIndex,
const OpenGl_Vec4& theValue);
public:
//! Specifies the value of the integer uniform variable.

36
src/OpenGl/OpenGl_Structure.cxx
View File

@ -13,10 +13,6 @@
// 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
#include <OpenGl_CappingAlgo.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_GlCore11.hxx>
@ -145,13 +141,11 @@ OpenGl_Structure::OpenGl_Structure (const Handle(Graphic3d_StructureManager)& th
myAspectText(NULL),
myHighlightColor(NULL),
myNamedStatus(0),
myZLayer(0)
myZLayer(0),
myIsRaytracable (Standard_False),
myModificationState (0)
{
UpdateNamedStatus();
#if HAVE_OPENCL
myIsRaytracable = Standard_False;
myModificationState = 0;
#endif
}
// =======================================================================
@ -199,12 +193,10 @@ void OpenGl_Structure::UpdateTransformation()
matcpy (myTransformation->mat, &Graphic3d_CStructure::Transformation[0][0]);
#ifdef HAVE_OPENCL
if (myIsRaytracable)
{
UpdateStateWithAncestorStructures();
}
#endif
}
// =======================================================================
@ -247,12 +239,10 @@ void OpenGl_Structure::SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect)
}
myAspectFace->SetAspect (theAspect);
#ifdef HAVE_OPENCL
if (myIsRaytracable)
{
UpdateStateWithAncestorStructures();
}
#endif
}
// =======================================================================
@ -382,16 +372,12 @@ void OpenGl_Structure::UpdateNamedStatus()
if (highlight) myNamedStatus |= OPENGL_NS_HIGHLIGHT;
if (!visible) myNamedStatus |= OPENGL_NS_HIDE;
#ifdef HAVE_OPENCL
if (myIsRaytracable)
{
UpdateStateWithAncestorStructures();
}
#endif
}
#ifdef HAVE_OPENCL
// =======================================================================
// function : RegisterAncestorStructure
// purpose :
@ -494,8 +480,6 @@ void OpenGl_Structure::SetRaytracableWithAncestorStructures() const
}
}
#endif
// =======================================================================
// function : Connect
// purpose :
@ -506,7 +490,6 @@ void OpenGl_Structure::Connect (Graphic3d_CStructure& theStructure)
Disconnect (theStructure);
myConnected.Append (aStruct);
#ifdef HAVE_OPENCL
if (aStruct->IsRaytracable())
{
UpdateStateWithAncestorStructures();
@ -514,7 +497,6 @@ void OpenGl_Structure::Connect (Graphic3d_CStructure& theStructure)
}
aStruct->RegisterAncestorStructure (this);
#endif
}
// =======================================================================
@ -531,7 +513,6 @@ void OpenGl_Structure::Disconnect (Graphic3d_CStructure& theStructure)
{
myConnected.Remove (anIter);
#ifdef HAVE_OPENCL
if (aStruct->IsRaytracable())
{
UpdateStateWithAncestorStructures();
@ -539,7 +520,6 @@ void OpenGl_Structure::Disconnect (Graphic3d_CStructure& theStructure)
}
aStruct->UnregisterAncestorStructure (this);
#endif
return;
}
}
@ -574,13 +554,11 @@ void OpenGl_Structure::RemoveGroup (const Handle(Graphic3d_Group)& theGroup)
{
theGroup->Clear (Standard_False);
#ifdef HAVE_OPENCL
if (((OpenGl_Group* )theGroup.operator->())->IsRaytracable())
{
UpdateStateWithAncestorStructures();
UpdateRaytracableWithAncestorStructures();
}
#endif
myGroups.Remove (aGroupIter);
return;
@ -603,29 +581,23 @@ void OpenGl_Structure::Clear()
// =======================================================================
void OpenGl_Structure::Clear (const Handle(OpenGl_Context)& theGlCtx)
{
#ifdef HAVE_OPENCL
Standard_Boolean aRaytracableGroupDeleted (Standard_False);
#endif
// Release groups
for (OpenGl_Structure::GroupIterator aGroupIter (myGroups); aGroupIter.More(); aGroupIter.Next())
{
#ifdef HAVE_OPENCL
aRaytracableGroupDeleted |= aGroupIter.Value()->IsRaytracable();
#endif
// Delete objects
aGroupIter.ChangeValue()->Release (theGlCtx);
}
myGroups.Clear();
#ifdef HAVE_OPENCL
if (aRaytracableGroupDeleted)
{
UpdateStateWithAncestorStructures();
UpdateRaytracableWithAncestorStructures();
}
#endif
}
// =======================================================================
@ -846,10 +818,8 @@ void OpenGl_Structure::Release (const Handle(OpenGl_Context)& theGlCtx)
OpenGl_Element::Destroy (theGlCtx, myAspectText);
clearHighlightColor (theGlCtx);
#ifdef HAVE_OPENCL
// Remove from connected list of ancestor
UnregisterFromAncestorStructure();
#endif
}
// =======================================================================

10
src/OpenGl/OpenGl_Structure.hxx
View File

@ -160,8 +160,6 @@ public:
//! Returns OpenGL persistent translation.
const TEL_TRANSFORM_PERSISTENCE* PersistentTranslation() const { return myTransPers; }
#ifdef HAVE_OPENCL
//! Returns structure modification state (for ray-tracing).
Standard_Size ModificationState() const { return myModificationState; }
@ -171,14 +169,10 @@ public:
//! Is the structure ray-tracable (contains ray-tracable elements)?
Standard_Boolean IsRaytracable() const { return myIsRaytracable; }
#endif
protected:
Standard_EXPORT virtual ~OpenGl_Structure();
#ifdef HAVE_OPENCL
//! Registers ancestor connected structure (for updating ray-tracing state).
void RegisterAncestorStructure (const OpenGl_Structure* theStructure) const;
@ -197,8 +191,6 @@ protected:
//! Sets ray-tracable status for structure and its parents.
void SetRaytracableWithAncestorStructures() const;
#endif
protected:
OpenGl_Matrix* myTransformation;
@ -216,11 +208,9 @@ protected:
OpenGl_ListOfStructure myConnected;
#ifdef HAVE_OPENCL
mutable OpenGl_ListOfStructure myAncestorStructures;
mutable Standard_Boolean myIsRaytracable;
mutable Standard_Size myModificationState;
#endif
public:

39
src/OpenGl/OpenGl_TextureBufferArb.cxx
View File

@ -127,6 +127,45 @@ bool OpenGl_TextureBufferArb::Init (const Handle(OpenGl_Context)& theGlCtx,
return true;
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
bool OpenGl_TextureBufferArb::Init (const Handle(OpenGl_Context)& theGlCtx,
const GLuint theComponentsNb,
const GLsizei theElemsNb,
const GLuint* theData)
{
if (theComponentsNb != 1
&& theComponentsNb != 2
&& theComponentsNb != 3
&& theComponentsNb != 4)
{
// unsupported format
return false;
}
else if (!Create (theGlCtx)
|| !OpenGl_VertexBuffer::Init (theGlCtx, theComponentsNb, theElemsNb, theData))
{
return false;
}
switch (theComponentsNb)
{
case 1: myTexFormat = GL_R32I; break;
case 2: myTexFormat = GL_RG32I; break;
case 3: myTexFormat = GL_RGB32I; break;
case 4: myTexFormat = GL_RGBA32I; break;
}
Bind (theGlCtx);
BindTexture (theGlCtx);
theGlCtx->arbTBO->glTexBuffer (GetTarget(), myTexFormat, myBufferId);
UnbindTexture (theGlCtx);
Unbind (theGlCtx);
return true;
}
// =======================================================================
// function : BindTexture
// purpose :

7
src/OpenGl/OpenGl_TextureBufferArb.hxx
View File

@ -69,6 +69,13 @@ public:
const GLsizei theElemsNb,
const GLfloat* theData);
//! Perform TBO initialization with specified data.
//! Existing data will be deleted.
Standard_EXPORT bool Init (const Handle(OpenGl_Context)& theGlCtx,
const GLuint theComponentsNb,
const GLsizei theElemsNb,
const GLuint* theData);
//! Bind TBO to specified Texture Unit.
Standard_EXPORT void BindTexture (const Handle(OpenGl_Context)& theGlCtx,
const GLenum theTextureUnit = GL_TEXTURE0) const;

10
src/OpenGl/OpenGl_View.cxx
View File

@ -13,10 +13,6 @@
// 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
#include <NCollection_Mat4.hxx>
#include <OpenGl_Context.hxx>
@ -97,9 +93,7 @@ OpenGl_View::OpenGl_View (const CALL_DEF_VIEWCONTEXT &AContext,
myCurrLightSourceState = myStateCounter->Increment();
#ifdef HAVE_OPENCL
myModificationState = 1; // initial state
#endif
}
/*----------------------------------------------------------------------*/
@ -145,18 +139,14 @@ void OpenGl_View::SetTextureEnv (const Handle(OpenGl_Context)& theCtx,
if (!anImage.IsNull())
myTextureEnv->Init (theCtx, *anImage.operator->(), theTexture->Type());
#ifdef HAVE_OPENCL
myModificationState++;
#endif
}
void OpenGl_View::SetSurfaceDetail (const Visual3d_TypeOfSurfaceDetail theMode)
{
mySurfaceDetail = theMode;
#ifdef HAVE_OPENCL
myModificationState++;
#endif
}
// =======================================================================

6
src/OpenGl/OpenGl_View.hxx
View File

@ -171,7 +171,7 @@ class OpenGl_View : public MMgt_TShared
const Aspect_CLayer2d& theCOverLayer);
void DrawBackground (const Handle(OpenGl_Workspace)& theWorkspace);
void DrawBackground (OpenGl_Workspace& theWorkspace);
//! Returns list of OpenGL Z-layers.
const OpenGl_LayerList& LayerList() const { return myZLayers; }
@ -194,10 +194,8 @@ class OpenGl_View : public MMgt_TShared
return myImmediateList;
}
#ifdef HAVE_OPENCL
//! Returns modification state for ray-tracing.
Standard_Size ModificationState() const { return myModificationState; }
#endif
protected:
@ -269,9 +267,7 @@ protected:
StateInfo myLastViewMappingState;
StateInfo myLastLightSourceState;
#ifdef HAVE_OPENCL
Standard_Size myModificationState;
#endif
public:

16
src/OpenGl/OpenGl_View_2.cxx
View File

@ -157,13 +157,13 @@ static void bind_light (const OpenGl_Light& theLight,
/*----------------------------------------------------------------------*/
void OpenGl_View::DrawBackground (const Handle(OpenGl_Workspace)& theWorkspace)
void OpenGl_View::DrawBackground (OpenGl_Workspace& theWorkspace)
{
if ( (theWorkspace->NamedStatus & OPENGL_NS_WHITEBACK) == 0 &&
if ( (theWorkspace.NamedStatus & OPENGL_NS_WHITEBACK) == 0 &&
( myBgTexture.TexId != 0 || myBgGradient.type != Aspect_GFM_NONE ) )
{
const Standard_Integer aViewWidth = theWorkspace->Width();
const Standard_Integer aViewHeight = theWorkspace->Height();
const Standard_Integer aViewWidth = theWorkspace.Width();
const Standard_Integer aViewHeight = theWorkspace.Height();
glPushAttrib( GL_ENABLE_BIT | GL_TEXTURE_BIT );
@ -319,7 +319,7 @@ void OpenGl_View::DrawBackground (const Handle(OpenGl_Workspace)& theWorkspace)
glDisable( GL_BLEND ); //push GL_ENABLE_BIT
glColor3fv (theWorkspace->BackgroundColor().rgb);
glColor3fv (theWorkspace.BackgroundColor().rgb);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); //push GL_TEXTURE_BIT
// Note that texture is mapped using GL_REPEAT wrapping mode so integer part
@ -340,11 +340,11 @@ void OpenGl_View::DrawBackground (const Handle(OpenGl_Workspace)& theWorkspace)
glPopAttrib(); //GL_ENABLE_BIT | GL_TEXTURE_BIT
if (theWorkspace->UseZBuffer())
if (theWorkspace.UseZBuffer())
glEnable (GL_DEPTH_TEST);
/* GL_DITHER on/off pour le trace */
if (theWorkspace->Dither())
if (theWorkspace.Dither())
glEnable (GL_DITHER);
else
glDisable (GL_DITHER);
@ -439,7 +439,7 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
// ====================================
// Render background
DrawBackground (theWorkspace);
DrawBackground (*theWorkspace);
// Switch off lighting by default
glDisable(GL_LIGHTING);

30
src/OpenGl/OpenGl_Workspace.cxx
View File

@ -146,6 +146,12 @@ OpenGl_Workspace::OpenGl_Workspace (const Handle(OpenGl_Display)& theDisplay,
NamedStatus (0),
HighlightColor (&THE_WHITE_COLOR),
//
myComputeInitStatus (OpenGl_RT_NONE),
myIsRaytraceDataValid (Standard_False),
myTraversalStackSize (THE_DEFAULT_STACK_SIZE),
myViewModificationStatus (0),
myLayersModificationStatus (0),
//
myTransientDrawToFront (Standard_True),
myBackBufferRestored (Standard_False),
myIsImmediateDrawn (Standard_False),
@ -186,18 +192,6 @@ OpenGl_Workspace::OpenGl_Workspace (const Handle(OpenGl_Display)& theDisplay,
// Polygon Offset
EnablePolygonOffset();
#ifdef HAVE_OPENCL
myComputeInitStatus = OpenGl_CLIS_NONE;
myViewModificationStatus = 0;
myLayersModificationStatus = 0;
myIsRaytraceDataValid = Standard_False;
myToUpdateRaytraceData = Standard_False;
#endif
}
// =======================================================================
@ -217,9 +211,7 @@ Standard_Boolean OpenGl_Workspace::SetImmediateModeDrawToFront (const Standard_B
// =======================================================================
OpenGl_Workspace::~OpenGl_Workspace()
{
#ifdef HAVE_OPENCL
ReleaseOpenCL();
#endif
ReleaseRaytraceResources();
}
// =======================================================================
@ -567,10 +559,8 @@ void OpenGl_Workspace::Redraw (const Graphic3d_CView& theCView,
toSwap = 0; // no need to swap buffers
}
#ifdef HAVE_OPENCL
if (!theCView.IsRaytracing || myComputeInitStatus == OpenGl_CLIS_FAIL)
if (!theCView.IsRaytracing || myComputeInitStatus == OpenGl_RT_FAIL)
{
#endif
const Standard_Boolean isImmediate = !myView->ImmediateStructures().IsEmpty();
redraw1 (theCView, theCUnderLayer, theCOverLayer, isImmediate ? 0 : toSwap);
if (isImmediate)
@ -579,18 +569,16 @@ void OpenGl_Workspace::Redraw (const Graphic3d_CView& theCView,
}
theCView.WasRedrawnGL = Standard_True;
#ifdef HAVE_OPENCL
}
else
{
int aSizeX = aFrameBuffer != NULL ? aFrameBuffer->GetVPSizeX() : myWidth;
int aSizeY = aFrameBuffer != NULL ? aFrameBuffer->GetVPSizeY() : myHeight;
Raytrace (theCView, aSizeX, aSizeY, toSwap);
Raytrace (theCView, aSizeX, aSizeY, toSwap, aFrameBuffer);
theCView.WasRedrawnGL = Standard_False;
}
#endif
if (aFrameBuffer != NULL)
{

290
src/OpenGl/OpenGl_Workspace.hxx
View File

@ -16,12 +16,8 @@
#ifndef _OpenGl_Workspace_Header
#define _OpenGl_Workspace_Header
#ifdef HAVE_OPENCL
#include <map>
#include <set>
#include <OpenGl_Cl.hxx>
#endif
#include <map>
#include <set>
#include <Handle_OpenGl_Workspace.hxx>
#include <OpenGl_Window.hxx>
@ -46,12 +42,11 @@
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_Display.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_Matrix.hxx>
#include <OpenGl_NamedStatus.hxx>
#include <OpenGl_PrinterContext.hxx>
#ifdef HAVE_OPENCL
#include <OpenGl_SceneGeometry.hxx>
#endif
#include <OpenGl_SceneGeometry.hxx>
#include <OpenGl_TextParam.hxx>
#include <OpenGl_RenderFilter.hxx>
#include <OpenGl_Vec.hxx>
@ -59,6 +54,10 @@
#include <Handle_OpenGl_View.hxx>
#include <Handle_OpenGl_Texture.hxx>
#include <OpenGl_ShaderObject.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_TextureBufferArb.hxx>
class OpenGl_AspectLine;
class OpenGl_AspectMarker;
class OpenGl_AspectText;
@ -233,24 +232,119 @@ protected:
void setTextureParams (Handle(OpenGl_Texture)& theTexture,
const Handle(Graphic3d_TextureParams)& theParams);
#ifdef HAVE_OPENCL
public:
//! Returns information about OpenCL device used for computations.
Standard_Boolean GetOpenClDeviceInfo (
NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>& theInfo) const;
protected:
//! Describes result of OpenCL initializing.
enum OpenClInitStatus
//! Result of OpenGL shaders initialization.
enum RaytraceInitStatus
{
OpenGl_CLIS_NONE,
OpenGl_CLIS_INIT,
OpenGl_CLIS_FAIL
OpenGl_RT_NONE,
OpenGl_RT_INIT,
OpenGl_RT_FAIL
};
//! Defines frequently used shader variables.
enum ShaderVariableIndex
{
OpenGl_RT_aPosition,
OpenGl_RT_uOriginLT,
OpenGl_RT_uOriginLB,
OpenGl_RT_uOriginRT,
OpenGl_RT_uOriginRB,
OpenGl_RT_uDirectLT,
OpenGl_RT_uDirectLB,
OpenGl_RT_uDirectRT,
OpenGl_RT_uDirectRB,
OpenGl_RT_uSceneRad,
OpenGl_RT_uSceneEps,
OpenGl_RT_uLightAmbnt,
OpenGl_RT_uLightCount,
OpenGl_RT_uShadEnabled,
OpenGl_RT_uReflEnabled,
OpenGl_RT_uInputTexture,
OpenGl_RT_uOffsetX,
OpenGl_RT_uOffsetY,
OpenGl_RT_uSamples,
OpenGl_RT_NbVariables // special field
};
//! Defines texture samplers.
enum ShaderSamplerNames
{
OpenGl_RT_SceneNodeInfoTexture = 0,
OpenGl_RT_SceneMinPointTexture = 1,
OpenGl_RT_SceneMaxPointTexture = 2,
OpenGl_RT_ObjectNodeInfoTexture = 3,
OpenGl_RT_ObjectMinPointTexture = 4,
OpenGl_RT_ObjectMaxPointTexture = 5,
OpenGl_RT_GeometryVertexTexture = 6,
OpenGl_RT_GeometryNormalTexture = 7,
OpenGl_RT_GeometryTriangTexture = 8,
OpenGl_RT_EnvironmentMapTexture = 9,
OpenGl_RT_RaytraceMaterialTexture = 10,
OpenGl_RT_RaytraceLightSrcTexture = 11,
OpenGl_RT_FSAAInputTexture = 12
};
//! Tool class for management of shader sources.
class ShaderSource
{
public:
//! Creates new uninitialized shader source.
ShaderSource()
{
//
}
//! Creates new shader source from specified file.
ShaderSource (const TCollection_AsciiString& theFileName)
{
Load (&theFileName, 1);
}
public:
//! Returns prefix to insert before the source.
const TCollection_AsciiString& Prefix() const
{
return myPrefix;
}
//! Sets prefix to insert before the source.
void SetPrefix (const TCollection_AsciiString& thePrefix)
{
myPrefix = thePrefix;
}
//! Returns shader source combined with prefix.
TCollection_AsciiString Source() const;
//! Loads shader source from specified files.
void Load (const TCollection_AsciiString* theFileNames, const Standard_Integer theCount);
private:
TCollection_AsciiString mySource; //!< Source string of the shader object
TCollection_AsciiString myPrefix; //!< Prefix to insert before the source
};
//! Default size of traversal stack.
static const Standard_Integer THE_DEFAULT_STACK_SIZE = 24;
protected: //! @name methods related to ray-tracing
//! Updates 3D scene geometry for ray-tracing.
@ -301,47 +395,53 @@ protected: //! @name methods related to ray-tracing
Standard_Boolean AddRaytracePolygonArray (OpenGl_TriangleSet* theSet,
const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID);
//! Initializes OpenCL resources.
Standard_Boolean InitOpenCL();
//! Loads and compiles shader object from specified source.
Handle(OpenGl_ShaderObject) LoadShader (const ShaderSource& theSource, GLenum theType);
//! Releases OpenCL resources.
void ReleaseOpenCL();
//! Performs safe exit when shaders initialization fails.
Standard_Boolean SafeFailBack (const TCollection_ExtendedString& theMessage);
//! Resizes OpenCL output image.
Standard_Boolean ResizeRaytraceOutputBuffer (const cl_int theSizeX, const cl_int theSizeY);
//! Initializes OpenGL/GLSL shader programs.
Standard_Boolean InitRaytraceResources();
//! Writes scene geometry to OpenCl device.
Standard_Boolean WriteRaytraceSceneToDevice();
//! Releases OpenGL/GLSL shader programs.
void ReleaseRaytraceResources();
//! Runs OpenCL ray-tracing kernels.
Standard_Boolean RunRaytraceOpenCLKernelsOld (const Graphic3d_CView& theCView,
const GLfloat theOrigins[16],
const GLfloat theDirects[16],
const int theSizeX,
const int theSizeY);
//! Uploads ray-trace data to the GPU.
Standard_Boolean UploadRaytraceData();
//! 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);
//! Resizes OpenGL frame buffers.
Standard_Boolean ResizeRaytraceBuffers (const Standard_Integer theSizeX,
const Standard_Integer theSizeY);
//! Redraws the window using OpenCL ray tracing.
//! Generates viewing rays for corners of screen quad.
void UpdateCamera (const NCollection_Mat4<GLdouble>& theOrientation,
const NCollection_Mat4<GLdouble>& theViewMapping,
OpenGl_Vec3 theOrigins[4],
OpenGl_Vec3 theDirects[4]);
//! Runs ray-tracing shader programs.
Standard_Boolean RunRaytraceShaders (const Graphic3d_CView& theCView,
const Standard_Integer theSizeX,
const Standard_Integer theSizeY,
const OpenGl_Vec3 theOrigins[4],
const OpenGl_Vec3 theDirects[4],
OpenGl_FrameBuffer* theFrameBuffer);
//! Redraws the window using OpenGL/GLSL ray-tracing.
Standard_Boolean Raytrace (const Graphic3d_CView& theCView,
const int theSizeX, const int theSizeY, const Tint theToSwap);
const Standard_Integer theSizeX,
const Standard_Integer theSizeY,
const Standard_Boolean theToSwap,
OpenGl_FrameBuffer* theFrameBuffer);
protected: //! @name fields related to ray-tracing
//! Result of OpenCL initialization.
OpenClInitStatus myComputeInitStatus;
//! Is ATI/AMD OpenCL platform used?
Standard_Boolean myIsAmdComputePlatform;
//! Result of shaders initialization.
RaytraceInitStatus myComputeInitStatus;
//! Is geometry data valid?
Standard_Boolean myIsRaytraceDataValid;
//! Is geometry data musty be updated?
Standard_Boolean myToUpdateRaytraceData;
//! 3D scene geometry data for ray-tracing.
OpenGl_RaytraceGeometry myRaytraceGeometry;
@ -351,54 +451,57 @@ protected: //! @name fields related to ray-tracing
//! Scene epsilon to prevent self-intersections.
Standard_ShortReal myRaytraceSceneEpsilon;
//! OpenCL context.
cl_context myComputeContext;
//! OpenCL command queue.
cl_command_queue myComputeQueue;
//! OpenCL computing program.
cl_program myRaytraceProgram;
//! OpenCL ray-tracing render kernel.
cl_kernel myRaytraceRenderKernel;
//! OpenCL adaptive anti-aliasing kernel.
cl_kernel myRaytraceSmoothKernel;
//! Actual size of traversal stack in shader program.
Standard_Integer myTraversalStackSize;
//! OpenCL image to store environment map.
cl_mem myRaytraceEnvironment;
//! OpenCL image to store rendering result.
cl_mem myRaytraceOutputImage;
//! OpenCL image to store anti-aliasing result.
cl_mem myRaytraceOutputImageAA;
//! OpenGL/GLSL source of ray-tracing fragment shader.
ShaderSource myRaytraceShaderSource;
//! OpenGL/GLSL source of adaptive-AA fragment shader.
ShaderSource myPostFSAAShaderSource;
//! OpenGL texture to store rendering result.
Handle(OpenGl_Texture) myRaytraceOutputTexture;
//! OpenGL texture to store anti-aliasing result.
Handle(OpenGl_Texture) myRaytraceOutputTextureAA;
//! OpenGL/GLSL ray-tracing fragment shader.
Handle(OpenGl_ShaderObject) myRaytraceShader;
//! OpenGL/GLSL adaptive-AA fragment shader.
Handle(OpenGl_ShaderObject) myPostFSAAShader;
//! OpenCL buffer of material properties.
cl_mem myRaytraceMaterialBuffer;
//! OpenCL buffer of light source properties.
cl_mem myRaytraceLightSourceBuffer;
//! OpenGL/GLSL ray-tracing shader program.
Handle(OpenGl_ShaderProgram) myRaytraceProgram;
//! OpenGL/GLSL adaptive-AA shader program.
Handle(OpenGl_ShaderProgram) myPostFSAAProgram;
//! OpenCL buffer of vertex coords.
cl_mem myGeometryVertexBuffer;
//! OpenCL buffer of vertex normals.
cl_mem myGeometryNormalBuffer;
//! OpenCL buffer of triangle indices.
cl_mem myGeometryTriangBuffer;
//! Texture buffer of data records of high-level BVH nodes.
Handle(OpenGl_TextureBufferArb) mySceneNodeInfoTexture;
//! Texture buffer of minimum points of high-level BVH nodes.
Handle(OpenGl_TextureBufferArb) mySceneMinPointTexture;
//! Texture buffer of maximum points of high-level BVH nodes.
Handle(OpenGl_TextureBufferArb) mySceneMaxPointTexture;
//! 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;
//! Texture buffer of data records of bottom-level BVH nodes.
Handle(OpenGl_TextureBufferArb) myObjectNodeInfoTexture;
//! Texture buffer of minimum points of bottom-level BVH nodes.
Handle(OpenGl_TextureBufferArb) myObjectMinPointTexture;
//! Texture buffer of maximum points of bottom-level BVH nodes.
Handle(OpenGl_TextureBufferArb) myObjectMaxPointTexture;
//! 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;
//! Texture buffer of vertex coords.
Handle(OpenGl_TextureBufferArb) myGeometryVertexTexture;
//! Texture buffer of vertex normals.
Handle(OpenGl_TextureBufferArb) myGeometryNormalTexture;
//! Texture buffer of triangle indices.
Handle(OpenGl_TextureBufferArb) myGeometryTriangTexture;
//! Texture buffer of material properties.
Handle(OpenGl_TextureBufferArb) myRaytraceMaterialTexture;
//! Texture buffer of light source properties.
Handle(OpenGl_TextureBufferArb) myRaytraceLightSrcTexture;
//! Vertex buffer (VBO) for drawing dummy quad.
OpenGl_VertexBuffer myRaytraceScreenQuad;
//! Framebuffer (FBO) to perform adaptive FSAA.
Handle(OpenGl_FrameBuffer) myRaytraceFBO1;
//! Framebuffer (FBO) to perform adaptive FSAA.
Handle(OpenGl_FrameBuffer) myRaytraceFBO2;
//! State of OpenGL view.
Standard_Size myViewModificationStatus;
@ -408,7 +511,8 @@ protected: //! @name fields related to ray-tracing
//! State of OpenGL structures reflected to ray-tracing.
std::map<const OpenGl_Structure*, Standard_Size> myStructureStates;
#endif // HAVE_OPENCL
//! Cached locations of frequently used uniform variables.
Standard_Integer myUniformLocations[2][OpenGl_RT_NbVariables];
protected: //! @name protected fields

2178
src/OpenGl/OpenGl_Workspace_Raytrace.cxx
View File

File diff suppressed because it is too large Load Diff

768
src/Shaders/RaytraceBase.fs Normal file
View File

@ -0,0 +1,768 @@
//! Normalized pixel coordinates.
in vec2 vPixel;
//! Origin of viewing ray in left-top corner.
uniform vec3 uOriginLT;
//! Origin of viewing ray in left-bottom corner.
uniform vec3 uOriginLB;
//! Origin of viewing ray in right-top corner.
uniform vec3 uOriginRT;
//! Origin of viewing ray in right-bottom corner.
uniform vec3 uOriginRB;
//! Direction of viewing ray in left-top corner.
uniform vec3 uDirectLT;
//! Direction of viewing ray in left-bottom corner.
uniform vec3 uDirectLB;
//! Direction of viewing ray in right-top corner.
uniform vec3 uDirectRT;
//! Direction of viewing ray in right-bottom corner.
uniform vec3 uDirectRB;
//! Texture buffer of data records of high-level BVH nodes.
uniform isamplerBuffer uSceneNodeInfoTexture;
//! Texture buffer of minimum points of high-level BVH nodes.
uniform samplerBuffer uSceneMinPointTexture;
//! Texture buffer of maximum points of high-level BVH nodes.
uniform samplerBuffer uSceneMaxPointTexture;
//! Texture buffer of data records of bottom-level BVH nodes.
uniform isamplerBuffer uObjectNodeInfoTexture;
//! Texture buffer of minimum points of bottom-level BVH nodes.
uniform samplerBuffer uObjectMinPointTexture;
//! Texture buffer of maximum points of bottom-level BVH nodes.
uniform samplerBuffer uObjectMaxPointTexture;
//! Texture buffer of vertex coords.
uniform samplerBuffer uGeometryVertexTexture;
//! Texture buffer of vertex normals.
uniform samplerBuffer uGeometryNormalTexture;
//! Texture buffer of triangle indices.
uniform isamplerBuffer uGeometryTriangTexture;
//! Texture buffer of material properties.
uniform samplerBuffer uRaytraceMaterialTexture;
//! Texture buffer of light source properties.
uniform samplerBuffer uRaytraceLightSrcTexture;
//! Environment map texture.
uniform sampler2D uEnvironmentMapTexture;
//! Total number of light sources.
uniform int uLightCount;
//! Intensity of global ambient light.
uniform vec4 uGlobalAmbient;
//! Enables/disables environment map.
uniform int uEnvironmentEnable;
//! Enables/disables computation of shadows.
uniform int uShadowsEnable;
//! Enables/disables computation of reflections.
uniform int uReflectionsEnable;
//! Radius of bounding sphere of the scene.
uniform float uSceneRadius;
//! Scene epsilon to prevent self-intersections.
uniform float uSceneEpsilon;
/////////////////////////////////////////////////////////////////////////////////////////
// Specific data types
//! Stores ray parameters.
struct SRay
{
vec3 Origin;
vec3 Direct;
};
//! Stores intersection parameters.
struct SIntersect
{
float Time;
vec2 UV;
vec3 Normal;
};
/////////////////////////////////////////////////////////////////////////////////////////
// Some useful constants
#define MAXFLOAT 1e15f
#define SMALL vec3 (exp2 (-80.f))
#define ZERO vec3 (0.f, 0.f, 0.f)
#define UNIT vec3 (1.f, 1.f, 1.f)
#define AXIS_X vec3 (1.f, 0.f, 0.f)
#define AXIS_Y vec3 (0.f, 1.f, 0.f)
#define AXIS_Z vec3 (0.f, 0.f, 1.f)
/////////////////////////////////////////////////////////////////////////////////////////
// Functions for compute ray-object intersection
// =======================================================================
// function : GenerateRay
// purpose :
// =======================================================================
SRay GenerateRay (in vec2 thePixel)
{
vec3 aP0 = mix (uOriginLB, uOriginRB, thePixel.x);
vec3 aP1 = mix (uOriginLT, uOriginRT, thePixel.x);
vec3 aD0 = mix (uDirectLB, uDirectRB, thePixel.x);
vec3 aD1 = mix (uDirectLT, uDirectRT, thePixel.x);
return SRay (mix (aP0, aP1, thePixel.y),
mix (aD0, aD1, thePixel.y));
}
// =======================================================================
// function : IntersectSphere
// purpose : Computes ray-sphere intersection
// =======================================================================
float IntersectSphere (in SRay theRay, in float theRadius)
{
float aDdotD = dot (theRay.Direct, theRay.Direct);
float aDdotO = dot (theRay.Direct, theRay.Origin);
float aOdotO = dot (theRay.Origin, theRay.Origin);
float aD = aDdotO * aDdotO - aDdotD * (aOdotO - theRadius * theRadius);
if (aD > 0.f)
{
float aTime = (sqrt (aD) - aDdotO) * (1.f / aDdotD);
return aTime > 0.f ? aTime : MAXFLOAT;
}
return MAXFLOAT;
}
// =======================================================================
// function : IntersectTriangle
// purpose : Computes ray-triangle intersection (branchless version)
// =======================================================================
float IntersectTriangle (in SRay theRay,
in vec3 thePnt0,
in vec3 thePnt1,
in vec3 thePnt2,
out vec2 theUV,
out vec3 theNorm)
{
vec3 aEdge0 = thePnt1 - thePnt0;
vec3 aEdge1 = thePnt0 - thePnt2;
theNorm = cross (aEdge1, aEdge0);
vec3 aEdge2 = (1.f / dot (theNorm, theRay.Direct)) * (thePnt0 - theRay.Origin);
float aTime = dot (theNorm, aEdge2);
vec3 theVec = cross (theRay.Direct, aEdge2);
theUV.x = dot (theVec, aEdge1);
theUV.y = dot (theVec, aEdge0);
return bool (int(aTime >= 0.f) &
int(theUV.x >= 0.f) &
int(theUV.y >= 0.f) &
int(theUV.x + theUV.y <= 1.f)) ? aTime : MAXFLOAT;
}
//! Global stack shared between traversal functions.
int Stack[STACK_SIZE];
//! Identifies the absence of intersection.
#define INALID_HIT ivec4 (-1)
// =======================================================================
// function : ObjectNearestHit
// purpose : Finds intersection with nearest object triangle
// =======================================================================
ivec4 ObjectNearestHit (in int theBVHOffset, in int theVrtOffset, in int theTrgOffset,
in SRay theRay, in vec3 theInverse, inout SIntersect theHit, in int theSentinel)
{
int aHead = theSentinel; // stack pointer
int aNode = 0; // node to visit
ivec4 aTriIndex = INALID_HIT;
float aTimeOut;
float aTimeLft;
float aTimeRgh;
while (true)
{
ivec3 aData = texelFetch (uObjectNodeInfoTexture, aNode + theBVHOffset).xyz;
if (aData.x == 0) // if inner node
{
vec3 aNodeMinLft = texelFetch (uObjectMinPointTexture, aData.y + theBVHOffset).xyz;
vec3 aNodeMaxLft = texelFetch (uObjectMaxPointTexture, aData.y + theBVHOffset).xyz;
vec3 aNodeMinRgh = texelFetch (uObjectMinPointTexture, aData.z + theBVHOffset).xyz;
vec3 aNodeMaxRgh = texelFetch (uObjectMaxPointTexture, aData.z + theBVHOffset).xyz;
vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
vec3 aTimeMax = max (aTime0, aTime1);
vec3 aTimeMin = min (aTime0, aTime1);
aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeLft <= theHit.Time);
aTimeMax = max (aTime0, aTime1);
aTimeMin = min (aTime0, aTime1);
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeRgh <= theHit.Time);
if (bool(aHitLft & aHitRgh))
{
aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
}
else
{
if (bool(aHitLft | aHitRgh))
{
aNode = bool(aHitLft) ? aData.y : aData.z;
}
else
{
if (aHead == theSentinel)
return aTriIndex;
aNode = Stack[aHead--];
}
}
}
else // if leaf node
{
vec3 aNormal;
vec2 aParams;
for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
{
ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + theTrgOffset);
vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x + theVrtOffset).xyz;
vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y + theVrtOffset).xyz;
vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z + theVrtOffset).xyz;
float aTime = IntersectTriangle (theRay,
aPoint0,
aPoint1,
aPoint2,
aParams,
aNormal);
if (aTime < theHit.Time)
{
aTriIndex = aTriangle;
theHit = SIntersect (aTime, aParams, aNormal);
}
}
if (aHead == theSentinel)
return aTriIndex;
aNode = Stack[aHead--];
}
}
return aTriIndex;
}
// =======================================================================
// function : ObjectAnyHit
// purpose : Finds intersection with any object triangle
// =======================================================================
float ObjectAnyHit (in int theBVHOffset, in int theVrtOffset, in int theTrgOffset,
in SRay theRay, in vec3 theInverse, in float theDistance, in int theSentinel)
{
int aHead = theSentinel; // stack pointer
int aNode = 0; // node to visit
float aTimeOut;
float aTimeLft;
float aTimeRgh;
while (true)
{
ivec4 aData = texelFetch (uObjectNodeInfoTexture, aNode + theBVHOffset);
if (aData.x == 0) // if inner node
{
vec3 aNodeMinLft = texelFetch (uObjectMinPointTexture, aData.y + theBVHOffset).xyz;
vec3 aNodeMaxLft = texelFetch (uObjectMaxPointTexture, aData.y + theBVHOffset).xyz;
vec3 aNodeMinRgh = texelFetch (uObjectMinPointTexture, aData.z + theBVHOffset).xyz;
vec3 aNodeMaxRgh = texelFetch (uObjectMaxPointTexture, aData.z + theBVHOffset).xyz;
vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
vec3 aTimeMax = max (aTime0, aTime1);
vec3 aTimeMin = min (aTime0, aTime1);
aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeLft <= theDistance);
aTimeMax = max (aTime0, aTime1);
aTimeMin = min (aTime0, aTime1);
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeRgh <= theDistance);
if (bool(aHitLft & aHitRgh))
{
aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
}
else
{
if (bool(aHitLft | aHitRgh))
{
aNode = bool(aHitLft) ? aData.y : aData.z;
}
else
{
if (aHead == theSentinel)
return 1.f;
aNode = Stack[aHead--];
}
}
}
else // if leaf node
{
vec3 aNormal;
vec2 aParams;
for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
{
ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + theTrgOffset);
vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x + theVrtOffset).xyz;
vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y + theVrtOffset).xyz;
vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z + theVrtOffset).xyz;
float aTime = IntersectTriangle (theRay,
aPoint0,
aPoint1,
aPoint2,
aParams,
aNormal);
if (aTime < theDistance)
return 0.f;
}
if (aHead == theSentinel)
return 1.f;
aNode = Stack[aHead--];
}
}
return 1.f;
}
// =======================================================================
// function : SceneNearestHit
// purpose : Finds intersection with nearest scene triangle
// =======================================================================
ivec4 SceneNearestHit (in SRay theRay, in vec3 theInverse, inout SIntersect theHit)
{
int aHead = -1; // stack pointer
int aNode = 0; // node to visit
ivec4 aHitObject = INALID_HIT;
float aTimeOut;
float aTimeLft;
float aTimeRgh;
while (true)
{
ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
if (aData.x != 0) // if leaf node
{
vec3 aNodeMin = texelFetch (uSceneMinPointTexture, aNode).xyz;
vec3 aNodeMax = texelFetch (uSceneMaxPointTexture, aNode).xyz;
vec3 aTime0 = (aNodeMin - theRay.Origin) * theInverse;
vec3 aTime1 = (aNodeMax - theRay.Origin) * theInverse;
vec3 aTimes = min (aTime0, aTime1);
if (max (aTimes.x, max (aTimes.y, aTimes.z)) < theHit.Time)
{
ivec4 aTriIndex = ObjectNearestHit (
aData.y, aData.z, aData.w, theRay, theInverse, theHit, aHead);
if (aTriIndex.x != -1)
{
aHitObject = ivec4 (aTriIndex.x + aData.z, // vertex 0
aTriIndex.y + aData.z, // vertex 1
aTriIndex.z + aData.z, // vertex 2
aTriIndex.w); // material
}
}
if (aHead < 0)
return aHitObject;
aNode = Stack[aHead--];
}
else // if inner node
{
vec3 aNodeMinLft = texelFetch (uSceneMinPointTexture, aData.y).xyz;
vec3 aNodeMaxLft = texelFetch (uSceneMaxPointTexture, aData.y).xyz;
vec3 aNodeMinRgh = texelFetch (uSceneMinPointTexture, aData.z).xyz;
vec3 aNodeMaxRgh = texelFetch (uSceneMaxPointTexture, aData.z).xyz;
vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
vec3 aTimeMax = max (aTime0, aTime1);
vec3 aTimeMin = min (aTime0, aTime1);
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeLft <= theHit.Time);
aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
aTimeMax = max (aTime0, aTime1);
aTimeMin = min (aTime0, aTime1);
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeRgh <= theHit.Time);
if (bool(aHitLft & aHitRgh))
{
aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
}
else
{
if (bool(aHitLft | aHitRgh))
{
aNode = bool(aHitLft) ? aData.y : aData.z;
}
else
{
if (aHead < 0)
return aHitObject;
aNode = Stack[aHead--];
}
}
}
}
return aHitObject;
}
// =======================================================================
// function : SceneAnyHit
// purpose : Finds intersection with any scene triangle
// =======================================================================
float SceneAnyHit (in SRay theRay, in vec3 theInverse, in float theDistance)
{
int aHead = -1; // stack pointer
int aNode = 0; // node to visit
float aTimeOut;
float aTimeLft;
float aTimeRgh;
while (true)
{
ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
if (aData.x != 0) // if leaf node
{
bool isShadow = 0.f == ObjectAnyHit (
aData.y, aData.z, aData.w, theRay, theInverse, theDistance, aHead);
if (aHead < 0 || isShadow)
return isShadow ? 0.f : 1.f;
aNode = Stack[aHead--];
}
else // if inner node
{
vec3 aNodeMinLft = texelFetch (uSceneMinPointTexture, aData.y).xyz;
vec3 aNodeMaxLft = texelFetch (uSceneMaxPointTexture, aData.y).xyz;
vec3 aNodeMinRgh = texelFetch (uSceneMinPointTexture, aData.z).xyz;
vec3 aNodeMaxRgh = texelFetch (uSceneMaxPointTexture, aData.z).xyz;
vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
vec3 aTimeMax = max (aTime0, aTime1);
vec3 aTimeMin = min (aTime0, aTime1);
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeLft <= theDistance);
aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
aTimeMax = max (aTime0, aTime1);
aTimeMin = min (aTime0, aTime1);
aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.f) & int(aTimeRgh <= theDistance);
if (bool(aHitLft & aHitRgh))
{
aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
}
else
{
if (bool(aHitLft | aHitRgh))
{
aNode = bool(aHitLft) ? aData.y : aData.z;
}
else
{
if (aHead < 0)
return 1.f;
aNode = Stack[aHead--];
}
}
}
}
return 1.f;
}
#define PI 3.1415926f
// =======================================================================
// function : Latlong
// purpose : Converts world direction to environment texture coordinates
// =======================================================================
vec2 Latlong (in vec3 thePoint, in float theRadius)
{
float aPsi = acos (-thePoint.z / theRadius);
float aPhi = atan (thePoint.y, thePoint.x) + PI;
return vec2 (aPhi * 0.1591549f,
aPsi * 0.3183098f);
}
// =======================================================================
// function : SmoothNormal
// purpose : Interpolates normal across the triangle
// =======================================================================
vec3 SmoothNormal (in vec2 theUV, in ivec4 theTriangle)
{
vec3 aNormal0 = texelFetch (uGeometryNormalTexture, theTriangle.x).xyz;
vec3 aNormal1 = texelFetch (uGeometryNormalTexture, theTriangle.y).xyz;
vec3 aNormal2 = texelFetch (uGeometryNormalTexture, theTriangle.z).xyz;
return normalize (aNormal1 * theUV.x +
aNormal2 * theUV.y +
aNormal0 * (1.f - theUV.x - theUV.y));
}
#define THRESHOLD vec3 (0.1f, 0.1f, 0.1f)
#define MATERIAL_AMBN(index) (7 * index + 0)
#define MATERIAL_DIFF(index) (7 * index + 1)
#define MATERIAL_SPEC(index) (7 * index + 2)
#define MATERIAL_EMIS(index) (7 * index + 3)
#define MATERIAL_REFL(index) (7 * index + 4)
#define MATERIAL_REFR(index) (7 * index + 5)
#define MATERIAL_TRAN(index) (7 * index + 6)
#define LIGHT_POS(index) (2 * index + 1)
#define LIGHT_PWR(index) (2 * index + 0)
// =======================================================================
// function : Radiance
// purpose : Computes color of specified ray
// =======================================================================
vec4 Radiance (in SRay theRay, in vec3 theInverse)
{
vec3 aResult = vec3 (0.f);
vec4 aWeight = vec4 (1.f);
for (int aDepth = 0; aDepth < 5; ++aDepth)
{
SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);
ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit);
if (aTriIndex.x == -1)
{
if (aWeight.w != 0.f)
{
return vec4 (aResult.x,
aResult.y,
aResult.z,
aWeight.w);
}
if (bool(uEnvironmentEnable))
{
float aTime = IntersectSphere (theRay, uSceneRadius);
aResult.xyz += aWeight.xyz * textureLod (uEnvironmentMapTexture,
Latlong (theRay.Direct * aTime + theRay.Origin, uSceneRadius), 0.f).xyz;
}
return vec4 (aResult.x,
aResult.y,
aResult.z,
aWeight.w);
}
vec3 aPoint = theRay.Direct * aHit.Time + theRay.Origin;
vec3 aAmbient = vec3 (texelFetch (
uRaytraceMaterialTexture, MATERIAL_AMBN (aTriIndex.w)));
vec3 aDiffuse = vec3 (texelFetch (
uRaytraceMaterialTexture, MATERIAL_DIFF (aTriIndex.w)));
vec4 aSpecular = vec4 (texelFetch (
uRaytraceMaterialTexture, MATERIAL_SPEC (aTriIndex.w)));
vec2 aOpacity = vec2 (texelFetch (
uRaytraceMaterialTexture, MATERIAL_TRAN (aTriIndex.w)));
vec3 aNormal = SmoothNormal (aHit.UV, aTriIndex);
aHit.Normal = normalize (aHit.Normal);
for (int aLightIdx = 0; aLightIdx < uLightCount; ++aLightIdx)
{
vec4 aLight = texelFetch (
uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));
float aDistance = MAXFLOAT;
if (aLight.w != 0.f) // point light source
{
aDistance = length (aLight.xyz -= aPoint);
aLight.xyz *= 1.f / aDistance;
}
SRay aShadow = SRay (aPoint + aLight.xyz * uSceneEpsilon, aLight.xyz);
aShadow.Origin += aHit.Normal * uSceneEpsilon *
(dot (aHit.Normal, aLight.xyz) >= 0.f ? 1.f : -1.f);
float aVisibility = 1.f;
if (bool(uShadowsEnable))
{
vec3 aInverse = 1.f / max (abs (aLight.xyz), SMALL);
aInverse.x = aLight.x < 0.f ? -aInverse.x : aInverse.x;
aInverse.y = aLight.y < 0.f ? -aInverse.y : aInverse.y;
aInverse.z = aLight.z < 0.f ? -aInverse.z : aInverse.z;
aVisibility = SceneAnyHit (aShadow, aInverse, aDistance);
}
if (aVisibility > 0.f)
{
vec3 aIntensity = vec3 (texelFetch (
uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx)));
float aLdotN = dot (aShadow.Direct, aNormal);
if (aOpacity.y > 0.f) // force two-sided lighting
aLdotN = abs (aLdotN); // for transparent surfaces
if (aLdotN > 0.f)
{
float aRdotV = dot (reflect (aShadow.Direct, aNormal), theRay.Direct);
aResult.xyz += aWeight.xyz * aOpacity.x * aIntensity *
(aDiffuse * aLdotN + aSpecular.xyz * pow (max (0.f, aRdotV), aSpecular.w));
}
}
}
aResult.xyz += aWeight.xyz * uGlobalAmbient.xyz *
aAmbient * aOpacity.x * max (abs (dot (aNormal, theRay.Direct)), 0.5f);
if (aOpacity.x != 1.f)
{
aWeight *= aOpacity.y;
}
else
{
aWeight *= bool(uReflectionsEnable) ?
texelFetch (uRaytraceMaterialTexture, MATERIAL_REFL (aTriIndex.w)) : vec4 (0.f);
theRay.Direct = reflect (theRay.Direct, aNormal);
if (dot (theRay.Direct, aHit.Normal) < 0.f)
{
theRay.Direct = reflect (theRay.Direct, aHit.Normal);
}
theInverse = 1.0 / max (abs (theRay.Direct), SMALL);
theInverse.x = theRay.Direct.x < 0.0 ? -theInverse.x : theInverse.x;
theInverse.y = theRay.Direct.y < 0.0 ? -theInverse.y : theInverse.y;
theInverse.z = theRay.Direct.z < 0.0 ? -theInverse.z : theInverse.z;
aPoint += aHit.Normal * (dot (aHit.Normal, theRay.Direct) >= 0.f ? uSceneEpsilon : -uSceneEpsilon);
}
if (all (lessThanEqual (aWeight.xyz, THRESHOLD)))
{
return vec4 (aResult.x,
aResult.y,
aResult.z,
aWeight.w);
}
theRay.Origin = theRay.Direct * uSceneEpsilon + aPoint;
}
return vec4 (aResult.x,
aResult.y,
aResult.z,
aWeight.w);
}

12
src/Shaders/RaytraceBase.vs Normal file
View File

@ -0,0 +1,12 @@
in vec4 aPosition;
//! Normalized pixel coordinates.
out vec2 vPixel;
void main (void)
{
vPixel = vec2 ((aPosition.x + 1.f) * 0.5f,
(aPosition.y + 1.f) * 0.5f);
gl_Position = aPosition;
}

18
src/Shaders/RaytraceRender.fs Normal file
View File

@ -0,0 +1,18 @@
out vec4 OutColor;
// =======================================================================
// function : main
// purpose :
// =======================================================================
void main (void)
{
SRay aRay = GenerateRay (vPixel);
vec3 aInvDirect = 1.f / max (abs (aRay.Direct), SMALL);
aInvDirect = vec3 (aRay.Direct.x < 0.f ? -aInvDirect.x : aInvDirect.x,
aRay.Direct.y < 0.f ? -aInvDirect.y : aInvDirect.y,
aRay.Direct.z < 0.f ? -aInvDirect.z : aInvDirect.z);
OutColor = clamp (Radiance (aRay, aInvDirect), 0.f, 1.f);
}

79
src/Shaders/RaytraceSmooth.fs Normal file
View File

@ -0,0 +1,79 @@
//! Input ray-traced image.
uniform sampler2D uFSAAInputTexture;
//! Number of accumulated FSAA samples.
uniform int uSamples;
//! Sub-pixel offset in X direction for FSAA.
uniform float uOffsetX;
//! Sub-pixel offset in Y direction for FSAA.
uniform float uOffsetY;
//! Output pixel color.
out vec4 OutColor;
#define LUM_DIFFERENCE 0.085f
#define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)
// =======================================================================
// function : main
// purpose :
// =======================================================================
void main (void)
{
int aPixelX = int (gl_FragCoord.x);
int aPixelY = int (gl_FragCoord.y);
vec4 aClr0 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 0, aPixelY + 0), 0);
vec4 aClr1 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 0, aPixelY - 1), 0);
vec4 aClr2 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 0, aPixelY + 1), 0);
vec4 aClr3 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 1, aPixelY + 0), 0);
vec4 aClr4 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 1, aPixelY - 1), 0);
vec4 aClr5 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 1, aPixelY + 1), 0);
vec4 aClr6 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX - 1, aPixelY + 0), 0);
vec4 aClr7 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX - 1, aPixelY - 1), 0);
vec4 aClr8 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX - 1, aPixelY + 1), 0);
float aLum = dot (LUMA, aClr0.xyz);
bool aRender = abs (aClr1.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr2.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr3.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr4.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr5.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr6.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr7.w - aClr0.w) > LUM_DIFFERENCE ||
abs (aClr8.w - aClr0.w) > LUM_DIFFERENCE;
if (!aRender)
{
aRender = abs (dot (LUMA, aClr1.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr2.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr3.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr4.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr5.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr6.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr7.xyz) - aLum) > LUM_DIFFERENCE ||
abs (dot (LUMA, aClr8.xyz) - aLum) > LUM_DIFFERENCE;
}
vec4 aColor = aClr0;
if (aRender)
{
SRay aRay = GenerateRay (vPixel + vec2 (uOffsetX, uOffsetY));
vec3 aInvDirect = 1.f / max (abs (aRay.Direct), SMALL);
aInvDirect = vec3 (aRay.Direct.x < 0.f ? -aInvDirect.x : aInvDirect.x,
aRay.Direct.y < 0.f ? -aInvDirect.y : aInvDirect.y,
aRay.Direct.z < 0.f ? -aInvDirect.z : aInvDirect.z);
aColor = mix (aClr0, clamp (Radiance (aRay, aInvDirect), 0.f, 1.f), 1.f / uSamples);
}
OutColor = aColor;
}

1
src/TKOpenGl/EXTERNLIB
View File

@ -6,7 +6,6 @@ CSF_OpenGlLibs
CSF_objc
CSF_Appkit
CSF_IOKit
CSF_OPENCL
CSF_FREETYPE
CSF_GL2PS
CSF_user32

41
src/ViewerTest/ViewerTest_ViewerCommands.cxx
View File

@ -6288,44 +6288,6 @@ static int VLight (Draw_Interpretor& theDi,
return 0;
}
//==============================================================================
//function : VClInfo
//purpose : Prints info about active OpenCL device
//==============================================================================
static Standard_Integer VClInfo (Draw_Interpretor& theDi,
Standard_Integer,
const char**)
{
Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
if (aContextAIS.IsNull())
{
std::cerr << "Call vinit before!\n";
return 1;
}
Handle(OpenGl_GraphicDriver) aDrv = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
Graphic3d_CView* aCView = static_cast<Graphic3d_CView*> (ViewerTest::CurrentView()->View()->CView());
NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString> anInfo;
if (aDrv.IsNull()
|| aCView == NULL
|| !aDrv->GetOpenClDeviceInfo (*aCView, anInfo))
{
theDi << "OpenCL device info is unavailable!\n";
return 0;
}
theDi << "OpenCL device info:\n";
for (NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>::Iterator anIter (anInfo);
anIter.More(); anIter.Next())
{
theDi << anIter.Key() << ": \t" << anIter.Value() << "\n";
}
return 0;
}
//=======================================================================
//function : VRaytrace
//purpose : Enables/disables OpenCL-based ray-tracing
@ -6756,9 +6718,6 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
theCommands.Add("vraytrace",
"vraytrace 0|1",
__FILE__,VRaytrace,group);
theCommands.Add("vclinfo",
"vclinfo",
__FILE__,VClInfo,group);
theCommands.Add("vsetraytracemode",
"vsetraytracemode [shad=0|1] [refl=0|1] [aa=0|1]",
__FILE__,VSetRaytraceMode,group);

1
tests/v3d/raytrace/bug24130
View File

@ -23,7 +23,6 @@ vfit
# activate ray-tracing
vraytrace 1
vclinfo
set aModeNum 0
for { set aAAMode 0 } { $aAAMode <= 1 } { incr aAAMode } {

1
tests/v3d/raytrace/connected
View File

@ -24,7 +24,6 @@ vdump $::imagedir/${::casename}_OFF.png
# turn on ray tracing
vraytrace 1
vclinfo
vdump $::imagedir/${::casename}_rt1.png
vclear

1
tests/v3d/raytrace/plastic
View File

@ -25,7 +25,6 @@ if { "$aColorL" != "GREEN3" || "$aColorR" != "GREEN4" } {
}
vraytrace 1
vclinfo
set aColorL [vreadpixel 150 250 rgb name]
set aColorR [vreadpixel 250 250 rgb name]
#if { "$aColorL" != "GREEN3" || "$aColorR" != "GREEN4" } {