Fix reading name of shape from subtype of PRODUCT_DEFINITION STEP entity

* XCAFDoc_NotesTool, incorrect removing parent/child from XCAFDoc_GraphNode attribute in loops

adm/UDLIST

@@ -360,6 +360,7 @@ n XCAFApp
 n XCAFDimTolObjects
 n XCAFDoc
 n XCAFPrs
+n XCAFView
 n XSAlgo
 n XSControl
 n XmlMXCAFDoc

adm/genproj.tcl

@@ -1824,6 +1824,9 @@ proc osutils:tk:files { tkloc thePlatform } {
          "n" { set utyp "nocdlpack" }
          "x" { set utyp "executable" }
     }
+    if { $utyp == "" } {
+      puts "Error: '$loc' is undefined within UDLIST"
+    }
     if [array exists map] { unset map }
     osutils:tk:loadunit $loc map
     #puts " loc = $loc === > [array names map]"

src/AIS/AIS_Shape.cxx

@@ -981,7 +981,6 @@ void AIS_Shape::SetTransparency (const Standard_Real theValue)
     }
 
     const Handle(Prs3d_Presentation)& aPrs = aPrsModed.Presentation()->Presentation();
-    aPrs->SetDisplayPriority (10); // force highest priority for translucent objects
     for (Graphic3d_SequenceOfGroup::Iterator aGroupIt (aPrs->Groups()); aGroupIt.More(); aGroupIt.Next())
     {
       const Handle(Graphic3d_Group)& aGroup = aGroupIt.Value();
@@ -1037,7 +1036,6 @@ void AIS_Shape::UnsetTransparency()
         aGroup->SetGroupPrimitivesAspect (anAreaAsp);
       }
     }
-    aPrs->ResetDisplayPriority();
   }
 
   myRecomputeEveryPrs = Standard_False; // no mode to recalculate :only viewer update

src/AIS/AIS_Triangulation.cxx

@@ -105,11 +105,6 @@ void AIS_Triangulation::updatePresentation()
 
       const Handle(Prs3d_Presentation)& aPrs = aPrsModed.Presentation()->Presentation();
 
-      if (IsTransparent())
-      {
-        aPrs->SetDisplayPriority (10); // force highest priority for translucent objects
-      }
-
       for (Graphic3d_SequenceOfGroup::Iterator aGroupIt (aPrs->Groups()); aGroupIt.More(); aGroupIt.Next())
       {
         const Handle(Graphic3d_Group)& aGroup = aGroupIt.Value();
@@ -118,11 +113,6 @@ void AIS_Triangulation::updatePresentation()
           aGroup->SetGroupPrimitivesAspect (anAreaAsp);
         }
       }
-
-      if (!IsTransparent())
-      {
-        aPrs->ResetDisplayPriority();
-      }
     }
 
     myRecomputeEveryPrs = Standard_False; // no mode to recalculate - only viewer update

src/BinMXCAFDoc/BinMXCAFDoc.cxx

@@ -17,6 +17,7 @@
 #include <BinMDF_ADriverTable.hxx>
 #include <BinMNaming_NamedShapeDriver.hxx>
 #include <BinMXCAFDoc.hxx>
+#include <BinMXCAFDoc_AssemblyItemRefDriver.hxx>
 #include <BinMXCAFDoc_AreaDriver.hxx>
 #include <BinMXCAFDoc_CentroidDriver.hxx>
 #include <BinMXCAFDoc_ColorDriver.hxx>
@@ -32,7 +33,13 @@
 #include <BinMXCAFDoc_LocationDriver.hxx>
 #include <BinMXCAFDoc_MaterialDriver.hxx>
 #include <BinMXCAFDoc_MaterialToolDriver.hxx>
+#include <BinMXCAFDoc_NoteDriver.hxx>
+#include <BinMXCAFDoc_NoteBinDataDriver.hxx>
+#include <BinMXCAFDoc_NoteCommentDriver.hxx>
+#include <BinMXCAFDoc_NotesToolDriver.hxx>
 #include <BinMXCAFDoc_ShapeToolDriver.hxx>
+#include <BinMXCAFDoc_ViewDriver.hxx>
+#include <BinMXCAFDoc_ViewToolDriver.hxx>
 #include <BinMXCAFDoc_VolumeDriver.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <TNaming_NamedShape.hxx>
@@ -42,7 +49,8 @@
 //purpose  : 
 //=======================================================================
 void BinMXCAFDoc::AddDrivers(const Handle(BinMDF_ADriverTable)& theDriverTable,
-			     const Handle(CDM_MessageDriver)& theMsgDrv) {
+			                       const Handle(CDM_MessageDriver)&   theMsgDrv) 
+{
   theDriverTable->AddDriver( new BinMXCAFDoc_AreaDriver     (theMsgDrv));
   theDriverTable->AddDriver( new BinMXCAFDoc_CentroidDriver (theMsgDrv));
   theDriverTable->AddDriver( new BinMXCAFDoc_ColorDriver    (theMsgDrv));
@@ -61,12 +69,16 @@ void BinMXCAFDoc::AddDrivers(const Handle(BinMDF_ADriverTable)& theDriverTable,
   }
   
   theDriverTable->AddDriver( aLocationDriver);
-  theDriverTable->AddDriver( new BinMXCAFDoc_VolumeDriver   (theMsgDrv));
-  theDriverTable->AddDriver( new BinMXCAFDoc_DatumDriver    (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_AssemblyItemRefDriver(theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_VolumeDriver      (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_DatumDriver       (theMsgDrv));
   theDriverTable->AddDriver( new BinMXCAFDoc_GeomToleranceDriver (theMsgDrv));
-  theDriverTable->AddDriver( new BinMXCAFDoc_DimensionDriver (theMsgDrv));
-  theDriverTable->AddDriver( new BinMXCAFDoc_DimTolDriver   (theMsgDrv));
-  theDriverTable->AddDriver( new BinMXCAFDoc_MaterialDriver (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_DimensionDriver   (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_DimTolDriver      (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_MaterialDriver    (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_NoteBinDataDriver (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_NoteCommentDriver (theMsgDrv));
+  theDriverTable->AddDriver (new BinMXCAFDoc_ViewDriver        (theMsgDrv));
 
   theDriverTable->AddDriver( new BinMXCAFDoc_ColorToolDriver   (theMsgDrv));
   theDriverTable->AddDriver( new BinMXCAFDoc_DocumentToolDriver(theMsgDrv));
@@ -74,4 +86,6 @@ void BinMXCAFDoc::AddDrivers(const Handle(BinMDF_ADriverTable)& theDriverTable,
   theDriverTable->AddDriver( new BinMXCAFDoc_ShapeToolDriver   (theMsgDrv));
   theDriverTable->AddDriver( new BinMXCAFDoc_DimTolToolDriver  (theMsgDrv));
   theDriverTable->AddDriver( new BinMXCAFDoc_MaterialToolDriver(theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_NotesToolDriver   (theMsgDrv));
+  theDriverTable->AddDriver( new BinMXCAFDoc_ViewToolDriver    (theMsgDrv));
 }

src/BinMXCAFDoc/BinMXCAFDoc.hxx

@@ -24,6 +24,7 @@ class BinMDF_ADriverTable;
 class CDM_MessageDriver;
 class BinMXCAFDoc_AreaDriver;
 class BinMXCAFDoc_CentroidDriver;
+class BinMXCAFDoc_ClippingPlaneToolDriver;
 class BinMXCAFDoc_ColorDriver;
 class BinMXCAFDoc_GraphNodeDriver;
 class BinMXCAFDoc_LocationDriver;
@@ -33,12 +34,17 @@ class BinMXCAFDoc_GeomToleranceDriver;
 class BinMXCAFDoc_DimensionDriver;
 class BinMXCAFDoc_DimTolDriver;
 class BinMXCAFDoc_MaterialDriver;
+class BinMXCAFDoc_NoteCommentDriver;
+class BinMXCAFDoc_NoteBinDataDriver;
+class BinMXCAFDoc_NotesToolDriver;
 class BinMXCAFDoc_ColorToolDriver;
 class BinMXCAFDoc_DocumentToolDriver;
 class BinMXCAFDoc_LayerToolDriver;
 class BinMXCAFDoc_ShapeToolDriver;
 class BinMXCAFDoc_DimTolToolDriver;
 class BinMXCAFDoc_MaterialToolDriver;
+class BinMXCAFDoc_ViewDriver;
+class BinMXCAFDoc_ViewToolDriver;
 
 
 
@@ -68,6 +74,7 @@ private:
 
 friend class BinMXCAFDoc_AreaDriver;
 friend class BinMXCAFDoc_CentroidDriver;
+friend class BinMXCAFDoc_ClippingPlaneToolDriver;
 friend class BinMXCAFDoc_ColorDriver;
 friend class BinMXCAFDoc_GraphNodeDriver;
 friend class BinMXCAFDoc_LocationDriver;
@@ -83,6 +90,8 @@ friend class BinMXCAFDoc_LayerToolDriver;
 friend class BinMXCAFDoc_ShapeToolDriver;
 friend class BinMXCAFDoc_DimTolToolDriver;
 friend class BinMXCAFDoc_MaterialToolDriver;
+friend class BinMXCAFDoc_ViewDriver;
+friend class BinMXCAFDoc_ViewToolDriver;
 
 };
 

src/BinMXCAFDoc/BinMXCAFDoc_AssemblyItemRefDriver.cxx

@@ -0,0 +1,111 @@
+// Created on: 2017-02-16
+// Created by: Eugeny NIKONOV
+// Copyright (c) 2005-2017 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.
+
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <BinMXCAFDoc_AssemblyItemRefDriver.hxx>
+#include <XCAFDoc_AssemblyItemRef.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_AssemblyItemRefDriver, BinMDF_ADriver)
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_AssemblyItemRefDriver::BinMXCAFDoc_AssemblyItemRefDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+  : BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_AssemblyItemRef)->Name())
+{
+
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_AssemblyItemRefDriver::NewEmpty() const
+{
+  return new XCAFDoc_AssemblyItemRef();
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_AssemblyItemRefDriver::Paste(const BinObjMgt_Persistent&  theSource,
+                                                          const Handle(TDF_Attribute)& theTarget,
+                                                          BinObjMgt_RRelocationTable&  /*theRelocTable*/) const
+{
+  Handle(XCAFDoc_AssemblyItemRef) aThis = Handle(XCAFDoc_AssemblyItemRef)::DownCast(theTarget);
+  if (aThis.IsNull())
+    return Standard_False;
+  
+  TCollection_AsciiString aPathStr;
+  if (!(theSource >> aPathStr))
+    return Standard_False;
+
+  aThis->SetItem(aPathStr);
+
+  Standard_Integer anExtraRef = 0;
+  if (!(theSource >> anExtraRef))
+    return Standard_False;
+
+  if (anExtraRef == 1)
+  {
+    Standard_GUID aGUID;
+    if (!(theSource >> aGUID))
+      return Standard_False;
+
+    aThis->SetGUID(aGUID);
+  }
+  else if (anExtraRef == 2)
+  {
+    Standard_Integer aSubshapeIndex;
+    if (!(theSource >> aSubshapeIndex))
+      return Standard_False;
+
+    aThis->SetSubshapeIndex(aSubshapeIndex);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_AssemblyItemRefDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					                                    BinObjMgt_Persistent&        theTarget,
+					                                    BinObjMgt_SRelocationTable&  /*theRelocTable*/) const
+{
+  Handle(XCAFDoc_AssemblyItemRef) aThis = Handle(XCAFDoc_AssemblyItemRef)::DownCast(theSource);
+  if (!aThis.IsNull())
+  {
+    theTarget << aThis->GetItem().ToString();
+    if (aThis->IsGUID())
+    {
+      theTarget << Standard_Integer(1);
+      theTarget << aThis->GetGUID();
+    }
+    else if (aThis->IsSubshapeIndex())
+    {
+      theTarget << Standard_Integer(2);
+      theTarget << aThis->GetSubshapeIndex();
+    }
+    else
+      theTarget << Standard_Integer(0);
+  }
+}

src/BinMXCAFDoc/BinMXCAFDoc_AssemblyItemRefDriver.hxx

@@ -0,0 +1,54 @@
+// Created on: 2017-02-16
+// Created by: Sergey NIKONOV
+// Copyright (c) 2005-2017 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 _BinMXCAFDoc_AssemblyItemRefDriver_HeaderFile
+#define _BinMXCAFDoc_AssemblyItemRefDriver_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <BinMDF_ADriver.hxx>
+#include <Standard_Boolean.hxx>
+#include <BinObjMgt_RRelocationTable.hxx>
+#include <BinObjMgt_SRelocationTable.hxx>
+
+class CDM_MessageDriver;
+class TDF_Attribute;
+class BinObjMgt_Persistent;
+
+class BinMXCAFDoc_AssemblyItemRefDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_AssemblyItemRefDriver, BinMDF_ADriver)
+
+class BinMXCAFDoc_AssemblyItemRefDriver : public BinMDF_ADriver
+{
+public:
+
+  Standard_EXPORT BinMXCAFDoc_AssemblyItemRefDriver(const Handle(CDM_MessageDriver)& theMsgDriver);
+
+  Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+
+  Standard_EXPORT Standard_Boolean Paste (const BinObjMgt_Persistent&  theSource, 
+                                          const Handle(TDF_Attribute)& theTarget, 
+                                          BinObjMgt_RRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT void Paste (const Handle(TDF_Attribute)& theSource, 
+                              BinObjMgt_Persistent&        theTarget, 
+                              BinObjMgt_SRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_AssemblyItemRefDriver, BinMDF_ADriver)
+
+};
+
+#endif // _BinMXCAFDoc_AssemblyItemRefDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_ClippingPlaneToolDriver.cxx

@@ -0,0 +1,65 @@
+// Created on: 2016-11-30
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <BinMXCAFDoc_ClippingPlaneToolDriver.hxx>
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <XCAFDoc_ClippingPlaneTool.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_ClippingPlaneToolDriver, BinMDF_ADriver)
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_ClippingPlaneToolDriver::BinMXCAFDoc_ClippingPlaneToolDriver
+  (const Handle(CDM_MessageDriver)& theMsgDriver)
+  : BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_ClippingPlaneTool)->Name())
+{
+}
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_ClippingPlaneToolDriver::NewEmpty() const
+{
+  return new XCAFDoc_ClippingPlaneTool();
+}
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_ClippingPlaneToolDriver::Paste
+  (const BinObjMgt_Persistent& /*theSource*/,
+  const Handle(TDF_Attribute)& /*theTarget*/,
+  BinObjMgt_RRelocationTable& /*theRelocTable*/) const
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_ClippingPlaneToolDriver::Paste
+  (const Handle(TDF_Attribute)& /*theSource*/,
+   BinObjMgt_Persistent& /*theTarget*/,
+   BinObjMgt_SRelocationTable& /*theRelocTable*/) const {
+}

src/BinMXCAFDoc/BinMXCAFDoc_ClippingPlaneToolDriver.hxx

@@ -0,0 +1,50 @@
+// Created on: 2016-11-30
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _BinMXCAFDoc_ClippingPlaneToolDriver_HeaderFile
+#define _BinMXCAFDoc_ClippingPlaneToolDriver_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <BinMDF_ADriver.hxx>
+#include <Standard_Boolean.hxx>
+#include <BinObjMgt_RRelocationTable.hxx>
+#include <BinObjMgt_SRelocationTable.hxx>
+class CDM_MessageDriver;
+class TDF_Attribute;
+class BinObjMgt_Persistent;
+
+
+class BinMXCAFDoc_DimTolToolDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_ClippingPlaneToolDriver, BinMDF_ADriver)
+
+
+class BinMXCAFDoc_ClippingPlaneToolDriver : public BinMDF_ADriver
+{
+public:
+
+  Standard_EXPORT BinMXCAFDoc_ClippingPlaneToolDriver(const Handle(CDM_MessageDriver)& theMsgDriver);
+
+  Standard_EXPORT virtual Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+
+  Standard_EXPORT virtual Standard_Boolean Paste(const BinObjMgt_Persistent& theSource, const Handle(TDF_Attribute)& theTarget, BinObjMgt_RRelocationTable& theRelocTable) const Standard_OVERRIDE;
+
+  Standard_EXPORT virtual void Paste(const Handle(TDF_Attribute)& theSource, BinObjMgt_Persistent& theTarget, BinObjMgt_SRelocationTable& theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_ClippingPlaneToolDriver, BinMDF_ADriver)
+
+};
+#endif // _BinMXCAFDoc_ClippingPlaneToolDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_NoteBinDataDriver.cxx

@@ -0,0 +1,96 @@
+// Created on: 2017-02-13
+// Created by: Eugeny NIKONOV
+// Copyright (c) 2005-2017 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.
+
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <TColStd_HArray1OfByte.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+#include <BinMXCAFDoc_NoteBinDataDriver.hxx>
+#include <XCAFDoc_NoteBinData.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_NoteBinDataDriver, BinMXCAFDoc_NoteDriver)
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_NoteBinDataDriver::BinMXCAFDoc_NoteBinDataDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+  : BinMXCAFDoc_NoteDriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_NoteBinData)->Name())
+{
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_NoteBinDataDriver::NewEmpty() const
+{
+  return new XCAFDoc_NoteBinData();
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_NoteBinDataDriver::Paste(const BinObjMgt_Persistent&  theSource,
+                                                      const Handle(TDF_Attribute)& theTarget,
+                                                      BinObjMgt_RRelocationTable&  theRelocTable) const
+{
+  if (!BinMXCAFDoc_NoteDriver::Paste(theSource, theTarget, theRelocTable))
+    return Standard_False;
+
+  Handle(XCAFDoc_NoteBinData) aNote = Handle(XCAFDoc_NoteBinData)::DownCast(theTarget);
+  if (aNote.IsNull())
+    return Standard_False;
+
+  TCollection_ExtendedString aTitle;
+  TCollection_AsciiString aMIMEtype;
+  Standard_Integer nbSize;
+  if (!(theSource >> aTitle >> aMIMEtype >> nbSize))
+    return Standard_False;
+
+  Handle(TColStd_HArray1OfByte) aData;
+  if (nbSize > 0)
+  {
+    aData.reset(new TColStd_HArray1OfByte(1, nbSize));
+    theSource.GetByteArray(&aData->ChangeFirst(), nbSize);
+  }
+
+  aNote->Set(aTitle, aMIMEtype, aData);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_NoteBinDataDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					                                BinObjMgt_Persistent&        theTarget,
+					                                BinObjMgt_SRelocationTable&  theRelocTable) const
+{
+  BinMXCAFDoc_NoteDriver::Paste(theSource, theTarget, theRelocTable);
+
+  Handle(XCAFDoc_NoteBinData) aNote = Handle(XCAFDoc_NoteBinData)::DownCast(theSource);
+  if (!aNote.IsNull())
+  {
+    theTarget << aNote->Title() << aNote->MIMEtype() << aNote->Size();
+    if (aNote->Size() > 0)
+      theTarget.PutByteArray(&aNote->Data()->ChangeFirst(), aNote->Size());
+  }
+}

src/BinMXCAFDoc/BinMXCAFDoc_NoteBinDataDriver.hxx

@@ -0,0 +1,44 @@
+// Created on: 2017-02-13
+// Created by: Sergey NIKONOV
+// Copyright (c) 2005-2017 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 _BinMXCAFDoc_NoteBinDataDriver_HeaderFile
+#define _BinMXCAFDoc_NoteBinDataDriver_HeaderFile
+
+#include <BinMXCAFDoc_NoteDriver.hxx>
+
+class BinMXCAFDoc_NoteBinDataDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_NoteBinDataDriver, BinMXCAFDoc_NoteDriver)
+
+class BinMXCAFDoc_NoteBinDataDriver : public BinMXCAFDoc_NoteDriver
+{
+public:
+  
+  Standard_EXPORT BinMXCAFDoc_NoteBinDataDriver(const Handle(CDM_MessageDriver)& theMsgDriver);
+  
+  Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+  
+  Standard_EXPORT Standard_Boolean Paste (const BinObjMgt_Persistent&  theSource, 
+                                          const Handle(TDF_Attribute)& theTarget, 
+                                          BinObjMgt_RRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT void Paste (const Handle(TDF_Attribute)& theSource, 
+                              BinObjMgt_Persistent&        theTarget, 
+                              BinObjMgt_SRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_NoteBinDataDriver, BinMXCAFDoc_NoteDriver)
+
+};
+
+#endif // _BinMXCAFDoc_NoteBinDataDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_NoteCommentDriver.cxx

@@ -0,0 +1,80 @@
+// Created on: 2017-02-13
+// Created by: Eugeny NIKONOV
+// Copyright (c) 2005-2017 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.
+
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <BinMXCAFDoc_NoteCommentDriver.hxx>
+#include <XCAFDoc_NoteComment.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_NoteCommentDriver, BinMXCAFDoc_NoteDriver)
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_NoteCommentDriver::BinMXCAFDoc_NoteCommentDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+  : BinMXCAFDoc_NoteDriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_NoteComment)->Name())
+{
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_NoteCommentDriver::NewEmpty() const
+{
+  return new XCAFDoc_NoteComment();
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_NoteCommentDriver::Paste(const BinObjMgt_Persistent&  theSource,
+                                                      const Handle(TDF_Attribute)& theTarget,
+                                                      BinObjMgt_RRelocationTable&  theRelocTable) const
+{
+  if (!BinMXCAFDoc_NoteDriver::Paste(theSource, theTarget, theRelocTable))
+    return Standard_False;
+
+  Handle(XCAFDoc_NoteComment) aNote = Handle(XCAFDoc_NoteComment)::DownCast(theTarget);
+  if (aNote.IsNull())
+    return Standard_False;
+
+  TCollection_ExtendedString aComment;
+  if (!(theSource >> aComment))
+    return Standard_False;
+
+  aNote->Set(aComment);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_NoteCommentDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					                                BinObjMgt_Persistent&        theTarget,
+					                                BinObjMgt_SRelocationTable&  theRelocTable) const
+{
+  BinMXCAFDoc_NoteDriver::Paste(theSource, theTarget, theRelocTable);
+
+  Handle(XCAFDoc_NoteComment) aNote = Handle(XCAFDoc_NoteComment)::DownCast(theSource);
+  if (!aNote.IsNull())
+    theTarget << aNote->Comment();
+}

src/BinMXCAFDoc/BinMXCAFDoc_NoteCommentDriver.hxx

@@ -0,0 +1,44 @@
+// Created on: 2017-02-13
+// Created by: Sergey NIKONOV
+// Copyright (c) 2005-2017 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 _BinMXCAFDoc_NoteCommentDriver_HeaderFile
+#define _BinMXCAFDoc_NoteCommentDriver_HeaderFile
+
+#include <BinMXCAFDoc_NoteDriver.hxx>
+
+class BinMXCAFDoc_NoteCommentDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_NoteCommentDriver, BinMXCAFDoc_NoteDriver)
+
+class BinMXCAFDoc_NoteCommentDriver : public BinMXCAFDoc_NoteDriver
+{
+public:
+  
+  Standard_EXPORT BinMXCAFDoc_NoteCommentDriver(const Handle(CDM_MessageDriver)& theMsgDriver);
+  
+  Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+  
+  Standard_EXPORT Standard_Boolean Paste (const BinObjMgt_Persistent&  theSource, 
+                                          const Handle(TDF_Attribute)& theTarget, 
+                                          BinObjMgt_RRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT void Paste (const Handle(TDF_Attribute)& theSource, 
+                              BinObjMgt_Persistent&        theTarget, 
+                              BinObjMgt_SRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_NoteCommentDriver, BinMXCAFDoc_NoteDriver)
+
+};
+
+#endif // _BinMXCAFDoc_NoteCommentDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_NoteDriver.cxx

@@ -0,0 +1,68 @@
+// Created on: 2017-02-10
+// Created by: Eugeny NIKONOV
+// Copyright (c) 2005-2017 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.
+
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <BinMXCAFDoc_NoteDriver.hxx>
+#include <XCAFDoc_Note.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_NoteDriver, BinMDF_ADriver)
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_NoteDriver::BinMXCAFDoc_NoteDriver(const Handle(CDM_MessageDriver)& theMsgDriver,
+                                               Standard_CString                 theName)
+  : BinMDF_ADriver(theMsgDriver, theName)
+{
+
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_NoteDriver::Paste(const BinObjMgt_Persistent&  theSource,
+                                               const Handle(TDF_Attribute)& theTarget,
+                                               BinObjMgt_RRelocationTable&  /*theRelocTable*/) const
+{
+  Handle(XCAFDoc_Note) aNote = Handle(XCAFDoc_Note)::DownCast(theTarget);
+  if (aNote.IsNull())
+    return Standard_False;
+  
+  TCollection_ExtendedString aUserName, aTimeStamp;
+  if (!(theSource >> aUserName >> aTimeStamp))
+    return Standard_False;
+
+  aNote->Set(aUserName, aTimeStamp);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_NoteDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					                         BinObjMgt_Persistent&        theTarget,
+					                         BinObjMgt_SRelocationTable&  /*theRelocTable*/) const
+{
+  Handle(XCAFDoc_Note) aNote = Handle(XCAFDoc_Note)::DownCast(theSource);
+  if (!aNote.IsNull())
+    theTarget << aNote->UserName() << aNote->TimeStamp();
+}

src/BinMXCAFDoc/BinMXCAFDoc_NoteDriver.hxx

@@ -0,0 +1,55 @@
+// Created on: 2017-02-10
+// Created by: Sergey NIKONOV
+// Copyright (c) 2005-2017 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 _BinMXCAFDoc_NoteDriver_HeaderFile
+#define _BinMXCAFDoc_NoteDriver_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <BinMDF_ADriver.hxx>
+#include <Standard_Boolean.hxx>
+#include <BinObjMgt_RRelocationTable.hxx>
+#include <BinObjMgt_SRelocationTable.hxx>
+
+class CDM_MessageDriver;
+class TDF_Attribute;
+class BinObjMgt_Persistent;
+
+class BinMXCAFDoc_NoteDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_NoteDriver, BinMDF_ADriver)
+
+class BinMXCAFDoc_NoteDriver : public BinMDF_ADriver
+{
+public:
+  
+  Standard_EXPORT Standard_Boolean Paste (const BinObjMgt_Persistent&  theSource, 
+                                          const Handle(TDF_Attribute)& theTarget, 
+                                          BinObjMgt_RRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT void Paste (const Handle(TDF_Attribute)& theSource, 
+                              BinObjMgt_Persistent&        theTarget, 
+                              BinObjMgt_SRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_NoteDriver, BinMDF_ADriver)
+
+protected:
+
+  Standard_EXPORT BinMXCAFDoc_NoteDriver(const Handle(CDM_MessageDriver)& theMsgDriver,
+                                         Standard_CString                 theName);
+
+};
+
+#endif // _BinMXCAFDoc_NoteDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_NotesToolDriver.cxx

@@ -0,0 +1,62 @@
+// Created on: 2017-02-10
+// Created by: Eugeny NIKONOV
+// Copyright (c) 2005-2017 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.
+
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <BinMXCAFDoc_NotesToolDriver.hxx>
+#include <XCAFDoc_NotesTool.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_NotesToolDriver, BinMDF_ADriver)
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_NotesToolDriver::BinMXCAFDoc_NotesToolDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+  : BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_NotesTool)->Name())
+{
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_NotesToolDriver::NewEmpty() const 
+{
+  return new XCAFDoc_NotesTool();
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_NotesToolDriver::Paste(const BinObjMgt_Persistent&  /*theSource*/,
+                                                    const Handle(TDF_Attribute)& /*theTarget*/,
+                                                    BinObjMgt_RRelocationTable&  /*theRelocTable*/) const
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function :
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_NotesToolDriver::Paste(const Handle(TDF_Attribute)& /*theSource*/,
+					                              BinObjMgt_Persistent&        /*theTarget*/,
+					                              BinObjMgt_SRelocationTable&  /*theRelocTable*/) const
+{
+}

src/BinMXCAFDoc/BinMXCAFDoc_NotesToolDriver.hxx

@@ -0,0 +1,54 @@
+// Created on: 2017-02-10
+// Created by: Sergey NIKONOV
+// Copyright (c) 2005-2017 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 _BinMXCAFDoc_NotesToolDriver_HeaderFile
+#define _BinMXCAFDoc_NotesToolDriver_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <BinMDF_ADriver.hxx>
+#include <Standard_Boolean.hxx>
+#include <BinObjMgt_RRelocationTable.hxx>
+#include <BinObjMgt_SRelocationTable.hxx>
+
+class CDM_MessageDriver;
+class TDF_Attribute;
+class BinObjMgt_Persistent;
+
+class BinMXCAFDoc_NotesToolDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_NotesToolDriver, BinMDF_ADriver)
+
+class BinMXCAFDoc_NotesToolDriver : public BinMDF_ADriver
+{
+public:
+  
+  Standard_EXPORT BinMXCAFDoc_NotesToolDriver(const Handle(CDM_MessageDriver)& theMsgDriver);
+  
+  Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+  
+  Standard_EXPORT Standard_Boolean Paste (const BinObjMgt_Persistent&  theSource, 
+                                          const Handle(TDF_Attribute)& theTarget, 
+                                          BinObjMgt_RRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT void Paste (const Handle(TDF_Attribute)& theSource, 
+                              BinObjMgt_Persistent&        theTarget, 
+                              BinObjMgt_SRelocationTable&  theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_NotesToolDriver, BinMDF_ADriver)
+
+};
+
+#endif // _BinMXCAFDoc_NotesToolDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_ViewDriver.cxx

@@ -0,0 +1,63 @@
+// Created on: 2016-10-24
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <BinMXCAFDoc_ViewDriver.hxx>
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <XCAFDoc_View.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_ViewDriver, BinMDF_ADriver)
+
+//=======================================================================
+//function : Constructor
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_ViewDriver::BinMXCAFDoc_ViewDriver (const Handle(CDM_MessageDriver)& theMsgDriver)
+: BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_View)->Name())
+{
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_ViewDriver::NewEmpty() const
+{
+  return new XCAFDoc_View();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_ViewDriver::Paste (const BinObjMgt_Persistent&  /*theSource*/,
+                                                const Handle(TDF_Attribute)& /*theTarget*/,
+                                                BinObjMgt_RRelocationTable&  /*theRelocTable*/) const
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_ViewDriver::Paste (const Handle(TDF_Attribute)&  /*theSource*/,
+                                    BinObjMgt_Persistent&         /*theTarget*/,
+                                    BinObjMgt_SRelocationTable&   /*theRelocTable*/) const
+{
+}

src/BinMXCAFDoc/BinMXCAFDoc_ViewDriver.hxx

@@ -0,0 +1,56 @@
+// Created on: 2016-10-24
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _BinMXCAFDoc_ViewDriver_HeaderFile
+#define _BinMXCAFDoc_ViewDriver_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <BinMDF_ADriver.hxx>
+#include <Standard_Boolean.hxx>
+#include <BinObjMgt_RRelocationTable.hxx>
+#include <BinObjMgt_SRelocationTable.hxx>
+
+class CDM_MessageDriver;
+class TDF_Attribute;
+class BinObjMgt_Persistent;
+
+class BinMXCAFDoc_ViewDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_ViewDriver, BinMDF_ADriver)
+
+class BinMXCAFDoc_ViewDriver : public BinMDF_ADriver
+{
+
+public:
+
+  
+  Standard_EXPORT BinMXCAFDoc_ViewDriver (const Handle(CDM_MessageDriver)& theMsgDriver);
+  
+  Standard_EXPORT virtual Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+  
+  Standard_EXPORT virtual Standard_Boolean Paste (const BinObjMgt_Persistent& theSource,
+                                                  const Handle(TDF_Attribute)& theTarget,
+                                                  BinObjMgt_RRelocationTable& theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT virtual void Paste (const Handle(TDF_Attribute)& theSource,
+                                      BinObjMgt_Persistent& theTarget,
+                                      BinObjMgt_SRelocationTable& theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_ViewDriver, BinMDF_ADriver)
+
+};
+
+#endif // _BinMXCAFDoc_ViewDriver_HeaderFile

src/BinMXCAFDoc/BinMXCAFDoc_ViewToolDriver.cxx

@@ -0,0 +1,65 @@
+// Created on: 2016-10-24
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <BinMXCAFDoc_ViewToolDriver.hxx>
+#include <BinObjMgt_Persistent.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <XCAFDoc_ViewTool.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BinMXCAFDoc_ViewToolDriver, BinMDF_ADriver)
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+BinMXCAFDoc_ViewToolDriver::BinMXCAFDoc_ViewToolDriver
+  (const Handle(CDM_MessageDriver)& theMsgDriver)
+: BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(XCAFDoc_ViewTool)->Name())
+{
+}
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) BinMXCAFDoc_ViewToolDriver::NewEmpty() const
+{
+  return new XCAFDoc_ViewTool();
+}
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+Standard_Boolean BinMXCAFDoc_ViewToolDriver::Paste
+  (const BinObjMgt_Persistent& /*theSource*/,
+   const Handle(TDF_Attribute)& /*theTarget*/,
+   BinObjMgt_RRelocationTable& /*theRelocTable*/) const 
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+void BinMXCAFDoc_ViewToolDriver::Paste
+  (const Handle(TDF_Attribute)& /*theSource*/,
+   BinObjMgt_Persistent& /*theTarget*/,
+   BinObjMgt_SRelocationTable& /*theRelocTable*/) const {
+}

src/BinMXCAFDoc/BinMXCAFDoc_ViewToolDriver.hxx

@@ -0,0 +1,52 @@
+// Created on: 2016-10-24
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _BinMXCAFDoc_ViewToolDriver_HeaderFile
+#define _BinMXCAFDoc_ViewToolDriver_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <BinMDF_ADriver.hxx>
+#include <Standard_Boolean.hxx>
+#include <BinObjMgt_RRelocationTable.hxx>
+#include <BinObjMgt_SRelocationTable.hxx>
+class CDM_MessageDriver;
+class TDF_Attribute;
+class BinObjMgt_Persistent;
+
+
+class BinMXCAFDoc_ViewToolDriver;
+DEFINE_STANDARD_HANDLE(BinMXCAFDoc_ViewToolDriver, BinMDF_ADriver)
+
+
+class BinMXCAFDoc_ViewToolDriver : public BinMDF_ADriver
+{
+
+public:
+
+  
+  Standard_EXPORT BinMXCAFDoc_ViewToolDriver(const Handle(CDM_MessageDriver)& theMsgDriver);
+  
+  Standard_EXPORT virtual Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
+  
+  Standard_EXPORT virtual Standard_Boolean Paste (const BinObjMgt_Persistent& theSource, const Handle(TDF_Attribute)& theTarget, BinObjMgt_RRelocationTable& theRelocTable) const Standard_OVERRIDE;
+  
+  Standard_EXPORT virtual void Paste (const Handle(TDF_Attribute)& theSource, BinObjMgt_Persistent& theTarget, BinObjMgt_SRelocationTable& theRelocTable) const Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BinMXCAFDoc_ViewToolDriver, BinMDF_ADriver)
+
+};
+#endif // _BinMXCAFDoc_ViewToolDriver_HeaderFile

src/BinMXCAFDoc/FILES

@@ -1,9 +1,13 @@
 BinMXCAFDoc.cxx
 BinMXCAFDoc.hxx
+BinMXCAFDoc_AssemblyItemRefDriver.cxx
+BinMXCAFDoc_AssemblyItemRefDriver.hxx
 BinMXCAFDoc_AreaDriver.cxx
 BinMXCAFDoc_AreaDriver.hxx
 BinMXCAFDoc_CentroidDriver.cxx
 BinMXCAFDoc_CentroidDriver.hxx
+BinMXCAFDoc_ClippingPlaneToolDriver.cxx
+BinMXCAFDoc_ClippingPlaneToolDriver.hxx
 BinMXCAFDoc_ColorDriver.cxx
 BinMXCAFDoc_ColorDriver.hxx
 BinMXCAFDoc_ColorToolDriver.cxx
@@ -31,7 +35,19 @@ BinMXCAFDoc_MaterialDriver.cxx
 BinMXCAFDoc_MaterialDriver.hxx
 BinMXCAFDoc_MaterialToolDriver.cxx
 BinMXCAFDoc_MaterialToolDriver.hxx
+BinMXCAFDoc_NoteDriver.cxx
+BinMXCAFDoc_NoteDriver.hxx
+BinMXCAFDoc_NoteCommentDriver.cxx
+BinMXCAFDoc_NoteCommentDriver.hxx
+BinMXCAFDoc_NoteBinDataDriver.cxx
+BinMXCAFDoc_NoteBinDataDriver.hxx
+BinMXCAFDoc_NotesToolDriver.cxx
+BinMXCAFDoc_NotesToolDriver.hxx
 BinMXCAFDoc_ShapeToolDriver.cxx
 BinMXCAFDoc_ShapeToolDriver.hxx
+BinMXCAFDoc_ViewDriver.cxx
+BinMXCAFDoc_ViewDriver.hxx
+BinMXCAFDoc_ViewToolDriver.cxx
+BinMXCAFDoc_ViewToolDriver.hxx
 BinMXCAFDoc_VolumeDriver.cxx
 BinMXCAFDoc_VolumeDriver.hxx

src/BinTools/BinTools_ShapeSet.cxx

@@ -74,8 +74,8 @@ static Standard_OStream& operator <<(Standard_OStream& OS, const gp_Pnt P)
 //purpose  : 
 //=======================================================================
 
-BinTools_ShapeSet::BinTools_ShapeSet(const Standard_Boolean isWithTriangles)
-     :myFormatNb(3), myWithTriangles(isWithTriangles)
+BinTools_ShapeSet::BinTools_ShapeSet(const Standard_Boolean /*isWithTriangles*/)
+     :myFormatNb(3), myWithTriangles(Standard_True/*isWithTriangles*/)
 {}
 
 //=======================================================================
@@ -517,6 +517,12 @@ void  BinTools_ShapeSet::Read(TopoDS_Shape& S, Standard_IStream& IS,
     anOrient = (TopAbs_Orientation)aChar;
     Standard_Integer anIndx;
     BinTools::GetInteger(IS, anIndx);
+    Standard_Integer anInd = nbshapes - anIndx + 1;
+    if (anInd < 1 || anInd > myShapes.Extent())
+    {
+      S = TopoDS_Shape();
+      return;
+    }
     S = myShapes(nbshapes - anIndx + 1);
     S.Orientation(anOrient);
 

src/BinTools/BinTools_SurfaceSet.cxx

@@ -95,6 +95,8 @@ Standard_Integer  BinTools_SurfaceSet::Add(const Handle(Geom_Surface)& S)
 Handle(Geom_Surface)  BinTools_SurfaceSet::Surface
        (const Standard_Integer I)const 
 {
+  if (I < 1 || I > myMap.Extent())
+    return Handle(Geom_Surface)();
   return  Handle(Geom_Surface)::DownCast(myMap(I));
 }
 

src/Graphic3d/Graphic3d_RenderingParams.hxx

@@ -48,6 +48,8 @@ public:
   Graphic3d_RenderingParams()
   : Method                      (Graphic3d_RM_RASTERIZATION),
     NbMsaaSamples               (0),
+    IsOitEnabled                (Standard_True),
+    OitDepthWeight              (0.0f),
     // ray tracing parameters
     IsGlobalIlluminationEnabled (Standard_False),
     RaytracingDepth             (THE_DEFAULT_DEPTH),
@@ -90,6 +92,8 @@ public:
 
   Graphic3d_RenderingMode Method;                      //!< specifies rendering mode, Graphic3d_RM_RASTERIZATION by default
   Standard_Integer        NbMsaaSamples;               //!< number of MSAA samples (should be within 0..GL_MAX_SAMPLES, power-of-two number), 0 by default
+  Standard_Boolean        IsOitEnabled;                //!< enables/disables order-independent transparency for rasterization, True by default
+  Standard_ShortReal      OitDepthWeight;              //!< scalar factor [0-1] controlling influence of depth of a fragment to its final coverage
 
   Standard_Boolean        IsGlobalIlluminationEnabled; //!< enables/disables global illumination effects (path tracing)
   Standard_Integer        SamplesPerPixel;             //!< number of samples per pixel (SPP)

src/OpenGl/FILES

@@ -104,6 +104,7 @@ OpenGl_IndexBuffer.cxx
 OpenGl_IndexBuffer.hxx
 OpenGl_Layer.cxx
 OpenGl_Layer.hxx
+OpenGl_OitUniformState.hxx
 OpenGl_RenderFilter.cxx
 OpenGl_RenderFilter.hxx
 OpenGl_Sampler.cxx

src/OpenGl/OpenGl_CappingAlgo.cxx

@@ -27,14 +27,6 @@ IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter,OpenGl_RenderFilter)
 
 namespace
 {
-#if !defined(GL_ES_VERSION_2_0)
-  static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
-  static const GLint THE_FILLPRIM_TO   = GL_POLYGON;
-#else
-  static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
-  static const GLint THE_FILLPRIM_TO   = GL_TRIANGLE_FAN;
-#endif
-
   //! Render infinite capping plane.
   //! @param theWorkspace [in] the GL workspace, context state.
   //! @param thePlane [in] the graphical plane, for which the capping surface is rendered.
@@ -88,8 +80,14 @@ namespace
       theWorkspace->ApplyAspectFace();
 
       // evaluate number of pair faces
-      glDisable (GL_DEPTH_TEST);
-      glDepthMask (GL_FALSE);
+      if (theWorkspace->UseZBuffer())
+      {
+        glDisable (GL_DEPTH_TEST);
+      }
+      if (theWorkspace->UseDepthWrite())
+      {
+        glDepthMask (GL_FALSE);
+      }
       glStencilFunc (GL_ALWAYS, 1, 0x01);
       glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
 
@@ -119,10 +117,16 @@ namespace
 
       // render capping plane using the generated stencil mask
       glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-      glDepthMask (GL_TRUE);
+      if (theWorkspace->UseDepthWrite())
+      {
+        glDepthMask (GL_TRUE);
+      }
       glStencilFunc (GL_EQUAL, 1, 0x01);
       glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
-      glEnable (GL_DEPTH_TEST);
+      if (theWorkspace->UseZBuffer())
+      {
+        glEnable (GL_DEPTH_TEST);
+      }
 
       renderPlane (theWorkspace, thePlane, aRenderPlane->ToUseObjectProperties()
                                          ? aGroupIter.Value()->AspectFace()
@@ -160,7 +164,9 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
 
   // replace primitive groups rendering filter
   Handle(OpenGl_RenderFilter) aRenderFilter = theWorkspace->GetRenderFilter();
-  theWorkspace->SetRenderFilter (theWorkspace->DefaultCappingAlgoFilter());
+  Handle(OpenGl_CappingAlgoFilter) aCappingFilter = theWorkspace->DefaultCappingAlgoFilter();
+  aCappingFilter->SetPreviousFilter (aRenderFilter);
+  theWorkspace->SetRenderFilter (aCappingFilter);
 
   // prepare for rendering the clip planes
   glEnable (GL_STENCIL_TEST);
@@ -214,10 +220,16 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
 // function : CanRender
 // purpose  :
 // =======================================================================
-Standard_Boolean OpenGl_CappingAlgoFilter::CanRender (const OpenGl_Element* theElement)
+Standard_Boolean OpenGl_CappingAlgoFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                                         const OpenGl_Element* theGlElement)
 {
-  const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theElement);
+  if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement))
+  {
+    return Standard_False;
+  }
+
+  const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
   return aPArray != NULL
-      && aPArray->DrawMode() >= THE_FILLPRIM_FROM
-      && aPArray->DrawMode() <= THE_FILLPRIM_TO;
+      && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+      && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO;
 }

src/OpenGl/OpenGl_CappingAlgo.hxx

@@ -49,14 +49,23 @@ public:
   //! Default constructor.
   OpenGl_CappingAlgoFilter() {}
 
+  //! Sets the current active filter in workspace.
+  //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+  void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
   //! Checks whether the element can be rendered or not.
   //! @param theElement [in] the element to check.
   //! @return True if element can be rendered.
-  virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) Standard_OVERRIDE;
+  virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                         const OpenGl_Element* theGlElement) Standard_OVERRIDE;
+
+private:
+
+  Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
 
 public:
 
-  DEFINE_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter,OpenGl_RenderFilter)
+  DEFINE_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter, OpenGl_RenderFilter)
 };
 
 #endif

src/OpenGl/OpenGl_Context.cxx

@@ -127,6 +127,8 @@ OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
   arbNPTW  (Standard_False),
   arbTexRG (Standard_False),
   arbTexFloat (Standard_False),
+  arbTexHalfFloat (Standard_False),
+  arbSampleShading (Standard_False),
   arbTexBindless (NULL),
   arbTBO (NULL),
   arbTboRGB32 (Standard_False),
@@ -152,11 +154,13 @@ OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
   myMaxTexDim  (1024),
   myMaxClipPlanes (6),
   myMaxMsaaSamples(0),
+  myMaxDrawBuffers (1),
   myGlVerMajor (0),
   myGlVerMinor (0),
   myIsInitialized (Standard_False),
   myIsStereoBuffers (Standard_False),
   myIsGlNormalizeEnabled (Standard_False),
+  myHasHalfFloatTextures (Standard_False),
   myHasRayTracing (Standard_False),
   myHasRayTracingTextures (Standard_False),
   myHasRayTracingAdaptiveSampling (Standard_False),
@@ -171,7 +175,7 @@ OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
 #endif
   myToCullBackFaces (false),
   myReadBuffer (0),
-  myDrawBuffer (0),
+  myDrawBuffers (1),
   myDefaultVao (0),
   myIsGlDebugCtx (Standard_False),
   myResolutionRatio (1.0f)
@@ -371,18 +375,60 @@ void OpenGl_Context::SetReadBuffer (const Standard_Integer theReadBuffer)
 void OpenGl_Context::SetDrawBuffer (const Standard_Integer theDrawBuffer)
 {
 #if !defined(GL_ES_VERSION_2_0)
-  myDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffer) : theDrawBuffer;
-  if (myDrawBuffer < GL_COLOR_ATTACHMENT0
+  const Standard_Integer aDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffer) : theDrawBuffer;
+  if (aDrawBuffer < GL_COLOR_ATTACHMENT0
    && arbFBO != NULL)
   {
     arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
   }
-  ::glDrawBuffer (myDrawBuffer);
+  ::glDrawBuffer (aDrawBuffer);
+
+  myDrawBuffers.Clear();
+
+  if (aDrawBuffer != GL_NONE)
+  {
+    myDrawBuffers.SetValue (0, aDrawBuffer);
+  }
 #else
   (void )theDrawBuffer;
 #endif
 }
 
+// =======================================================================
+// function : SetDrawBuffers
+// purpose  :
+// =======================================================================
+void OpenGl_Context::SetDrawBuffers (const Standard_Integer theNb, const Standard_Integer* theDrawBuffers)
+{
+  Standard_ASSERT_RETURN (Functions()->glDrawBuffers != NULL, "Multiple render targets feature is not supported by the context", Standard_ASSERT_DO_NOTHING());
+
+  myDrawBuffers.Clear();
+
+  Standard_Boolean useDefaultFbo = Standard_False;
+  for (Standard_Integer anI = 0; anI < theNb; ++anI)
+  {
+#if !defined(GL_ES_VERSION_2_0)
+    const Standard_Integer aDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffers[anI]) : theDrawBuffers[anI];
+#else
+    const Standard_Integer aDrawBuffer = theDrawBuffers[anI];
+#endif
+    if (aDrawBuffer < GL_COLOR_ATTACHMENT0 && aDrawBuffer != GL_NONE)
+    {
+      useDefaultFbo = Standard_True;
+    }
+    else if (aDrawBuffer != GL_NONE)
+    {
+      myDrawBuffers.SetValue (anI, aDrawBuffer);
+    }
+  }
+  if (arbFBO != NULL && useDefaultFbo)
+  {
+    arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
+  }
+
+  Functions()->glDrawBuffers (theNb, (const GLenum*)theDrawBuffers);
+}
+
 // =======================================================================
 // function : SetCullBackFaces
 // purpose  :
@@ -419,9 +465,35 @@ void OpenGl_Context::FetchState()
     ::glGetIntegerv (GL_RENDER_MODE, &myRenderMode);
   }
 
-  // cache buffers state
+  // cache read buffers state
   ::glGetIntegerv (GL_READ_BUFFER, &myReadBuffer);
-  ::glGetIntegerv (GL_DRAW_BUFFER, &myDrawBuffer);
+
+  // cache draw buffers state
+  myDrawBuffers.Clear();
+
+  Standard_Integer aDrawBuffer;
+
+  if (myMaxDrawBuffers == 1)
+  {
+    ::glGetIntegerv (GL_DRAW_BUFFER, &aDrawBuffer);
+
+    if (aDrawBuffer != GL_NONE)
+    {
+      myDrawBuffers.SetValue (0, aDrawBuffer);
+    }
+  }
+  else
+  {
+    for (Standard_Integer anI = 0; anI < myMaxDrawBuffers; ++anI)
+    {
+      ::glGetIntegerv (GL_DRAW_BUFFER0 + anI, &aDrawBuffer);
+
+      if (aDrawBuffer != GL_NONE)
+      {
+        myDrawBuffers.SetValue (anI, aDrawBuffer);
+      }
+    }
+  }
 #endif
 }
 
@@ -1096,6 +1168,7 @@ void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
   myGlVerMajor = 0;
   myGlVerMinor = 0;
   myMaxMsaaSamples = 0;
+  myMaxDrawBuffers = 1;
   ReadGlVersion (myGlVerMajor, myGlVerMinor);
   myVendor = (const char* )::glGetString (GL_VENDOR);
   if (!caps->ffpEnable
@@ -1188,6 +1261,8 @@ void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
   arbNPTW     = Standard_True;
   arbTexRG    = IsGlGreaterEqual (3, 0)
              || CheckExtension ("GL_EXT_texture_rg");
+  arbSampleShading = IsGlGreaterEqual (3, 2)
+                  || CheckExtension ("GL_OES_sample_variables");
   extBgra     = CheckExtension ("GL_EXT_texture_format_BGRA8888");
   extAnis = CheckExtension ("GL_EXT_texture_filter_anisotropic");
   extPDS  = CheckExtension ("GL_OES_packed_depth_stencil");
@@ -1227,8 +1302,10 @@ void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
     hasHighp = Standard_True;
   }
 
-  arbTexFloat = IsGlGreaterEqual (3, 0)
-             && FindProc ("glTexImage3D", myFuncs->glTexImage3D);
+  arbTexFloat     = IsGlGreaterEqual (3, 0)
+                  && FindProc ("glTexImage3D", myFuncs->glTexImage3D);
+  arbTexHalfFloat = IsGlGreaterEqual (3, 0)
+                  || CheckExtension ("GL_OES_texture_half_float");
 
   const Standard_Boolean hasTexBuffer32  = IsGlGreaterEqual (3, 2) && FindProc ("glTexBuffer", myFuncs->glTexBuffer);
   const Standard_Boolean hasExtTexBuffer = CheckExtension ("GL_EXT_texture_buffer") && FindProc ("glTexBufferEXT", myFuncs->glTexBuffer);
@@ -1268,19 +1345,30 @@ void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
     }
   }
 
+  const Standard_Boolean hasDrawBuffersExt = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_EXT_draw_buffers"))
+                                          && FindProc ("glDrawBuffersEXT", myFuncs->glDrawBuffers);
+  // get number of maximum supported draw buffers
+  if (hasDrawBuffersExt)
+  {
+    glGetIntegerv (GL_MAX_DRAW_BUFFERS, &myMaxDrawBuffers);
+  }
 #else
 
   myTexClamp = IsGlGreaterEqual (1, 2) ? GL_CLAMP_TO_EDGE : GL_CLAMP;
 
-  hasTexRGBA8 = Standard_True;
-  arbNPTW     = CheckExtension ("GL_ARB_texture_non_power_of_two");
-  arbTexFloat = IsGlGreaterEqual (3, 0)
-             || CheckExtension ("GL_ARB_texture_float");
-  extBgra     = CheckExtension ("GL_EXT_bgra");
-  extAnis     = CheckExtension ("GL_EXT_texture_filter_anisotropic");
-  extPDS      = CheckExtension ("GL_EXT_packed_depth_stencil");
-  atiMem      = CheckExtension ("GL_ATI_meminfo");
-  nvxMem      = CheckExtension ("GL_NVX_gpu_memory_info");
+  hasTexRGBA8     = Standard_True;
+  arbNPTW         = CheckExtension ("GL_ARB_texture_non_power_of_two");
+  arbTexFloat     = IsGlGreaterEqual (3, 0)
+                  || CheckExtension ("GL_ARB_texture_float");
+  arbTexHalfFloat = IsGlGreaterEqual (3, 0)
+                  || CheckExtension ("GL_ARB_half_float_pixel");
+  arbSampleShading = IsGlGreaterEqual (4, 0)
+                  || CheckExtension("GL_ARB_sample_shading");
+  extBgra          = CheckExtension ("GL_EXT_bgra");
+  extAnis          = CheckExtension ("GL_EXT_texture_filter_anisotropic");
+  extPDS           = CheckExtension ("GL_EXT_packed_depth_stencil");
+  atiMem           = CheckExtension ("GL_ATI_meminfo");
+  nvxMem           = CheckExtension ("GL_NVX_gpu_memory_info");
 
   GLint aStereo = GL_FALSE;
   glGetIntegerv (GL_STEREO, &aStereo);
@@ -1288,6 +1376,12 @@ void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
 
   // get number of maximum clipping planes
   glGetIntegerv (GL_MAX_CLIP_PLANES,  &myMaxClipPlanes);
+
+  // get number of maximum supported draw buffers
+  if (IsGlGreaterEqual (2, 0))
+  {
+    glGetIntegerv (GL_MAX_DRAW_BUFFERS, &myMaxDrawBuffers);
+  }
 #endif
 
   glGetIntegerv (GL_MAX_TEXTURE_SIZE, &myMaxTexDim);
@@ -2848,7 +2942,6 @@ Handle(OpenGl_FrameBuffer) OpenGl_Context::SetDefaultFrameBuffer (const Handle(O
 // =======================================================================
 void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect,
                                          const Handle(Graphic3d_PresentationAttributes)& theHighlight,
-                                         const Standard_Boolean theUseDepthWrite,
                                          Standard_Integer& theRenderingPassFlags)
 {
   const Handle(Graphic3d_AspectFillArea3d)& anAspect = (!theHighlight.IsNull() && !theHighlight->BasicFillAreaAspect().IsNull())
@@ -2902,26 +2995,12 @@ void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect,
       theRenderingPassFlags |= OPENGL_NS_2NDPASSNEED;
     }
 
-    GLboolean aDepthMask = GL_TRUE;
     if (aTranspFront != 0.0f
      || aTranspBack  != 0.0f)
     {
       // render transparent
       myMatFront.Diffuse.a() = 1.0f - aTranspFront;
       myMatBack .Diffuse.a() = 1.0f - aTranspBack;
-      glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-      glEnable (GL_BLEND);
-      aDepthMask = GL_FALSE;
-    }
-    else
-    {
-      // render opaque
-      glBlendFunc (GL_ONE, GL_ZERO);
-      glDisable (GL_BLEND);
-    }
-    if (theUseDepthWrite)
-    {
-      glDepthMask (aDepthMask);
     }
   }
 

src/OpenGl/OpenGl_Context.hxx

@@ -24,9 +24,11 @@
 #include <Aspect_TypeOfLine.hxx>
 #include <NCollection_DataMap.hxx>
 #include <Graphic3d_DiagnosticInfo.hxx>
-#include <NCollection_Map.hxx>
+#include <NCollection_Array1.hxx>
 #include <NCollection_Handle.hxx>
 #include <NCollection_List.hxx>
+#include <NCollection_Map.hxx>
+#include <NCollection_SparseArray.hxx>
 #include <Message.hxx>
 #include <OpenGl_Caps.hxx>
 #include <OpenGl_LineAttributes.hxx>
@@ -43,6 +45,8 @@
 
 #include <NCollection_Shared.hxx>
 
+#include <vector>
+
 //! Forward declarations
 #if defined(__APPLE__)
   #import <TargetConditionals.h>
@@ -456,12 +460,18 @@ public:
   //! @return value for GL_MAX_SAMPLES
   Standard_Integer MaxMsaaSamples() const { return myMaxMsaaSamples; }
 
+  //! @return value for GL_MAX_DRAW_BUFFERS
+  Standard_Integer MaxDrawBuffers() const { return myMaxDrawBuffers; }
+
   //! Get maximum number of clip planes supported by OpenGl.
   //! This value is implementation dependent. At least 6
   //! planes should be supported by OpenGl (see specs).
   //! @return value for GL_MAX_CLIP_PLANES
   Standard_Integer MaxClipPlanes() const { return myMaxClipPlanes; }
 
+  //! @return TRUE if half-float textures are supported by OpenGl.
+  Standard_Boolean HasHalfFloatTextures() const { return myHasHalfFloatTextures; }
+
   //! @return TRUE if ray tracing mode is supported
   Standard_Boolean HasRayTracing() const { return myHasRayTracing; }
 
@@ -583,12 +593,18 @@ public: //! @name methods to alter or retrieve current state
   //! Switch read buffer, wrapper for ::glReadBuffer().
   Standard_EXPORT void SetReadBuffer (const Standard_Integer theReadBuffer);
 
-  //! Return active draw buffer.
-  Standard_Integer DrawBuffer() { return myDrawBuffer; }
+  //! Return active draw buffer attached to a render target referred by layout location.
+  Standard_Integer DrawBuffer (const Standard_Integer theLayoutIdx = 0)
+  {
+    return myDrawBuffers.IsBound (theLayoutIdx) ? myDrawBuffers.Value (theLayoutIdx) : GL_NONE;
+  }
 
   //! Switch draw buffer, wrapper for ::glDrawBuffer().
   Standard_EXPORT void SetDrawBuffer (const Standard_Integer theDrawBuffer);
 
+  //! Switch draw buffer, wrapper for ::glDrawBuffers (GLsizei, const GLenum*).
+  Standard_EXPORT void SetDrawBuffers (const Standard_Integer theNb, const Standard_Integer* theDrawBuffers);
+
   //! Switch read/draw buffers.
   void SetReadDrawBuffer (const Standard_Integer theBuffer)
   {
@@ -628,7 +644,6 @@ public: //! @name methods to alter or retrieve current state
   //! Setup current shading material.
   Standard_EXPORT void SetShadingMaterial (const OpenGl_AspectFace* theAspect,
                                            const Handle(Graphic3d_PresentationAttributes)& theHighlight,
-                                           const Standard_Boolean theUseDepthWrite,
                                            Standard_Integer& theRenderingPassFlags);
 
   //! Setup current color.
@@ -723,26 +738,28 @@ public: //! @name core profiles
 
 public: //! @name extensions
 
-  Standard_Boolean       hasHighp;       //!< highp in GLSL ES fragment shader is supported
-  Standard_Boolean       hasUintIndex;   //!< GLuint for index buffer is supported (always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_element_index_uint)
-  Standard_Boolean       hasTexRGBA8;    //!< always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_rgb8_rgba8
-  Standard_Boolean       arbNPTW;        //!< GL_ARB_texture_non_power_of_two
-  Standard_Boolean       arbTexRG;       //!< GL_ARB_texture_rg
-  Standard_Boolean       arbTexFloat;    //!< GL_ARB_texture_float (on desktop OpenGL - since 3.0 or as extension GL_ARB_texture_float; on OpenGL ES - since 3.0)
-  OpenGl_ArbTexBindless* arbTexBindless; //!< GL_ARB_bindless_texture
-  OpenGl_ArbTBO*         arbTBO;         //!< GL_ARB_texture_buffer_object
-  Standard_Boolean       arbTboRGB32;    //!< GL_ARB_texture_buffer_object_rgb32 (3-component TBO), in core since 4.0
-  OpenGl_ArbIns*         arbIns;         //!< GL_ARB_draw_instanced
-  OpenGl_ArbDbg*         arbDbg;         //!< GL_ARB_debug_output
-  OpenGl_ArbFBO*         arbFBO;         //!< GL_ARB_framebuffer_object
-  OpenGl_ArbFBOBlit*     arbFBOBlit;     //!< glBlitFramebuffer function, moved out from OpenGl_ArbFBO structure for compatibility with OpenGL ES 2.0
-  Standard_Boolean       extFragDepth;   //!< GL_EXT_frag_depth on OpenGL ES 2.0 (gl_FragDepthEXT built-in variable, before OpenGL ES 3.0)
-  OpenGl_ExtGS*          extGS;          //!< GL_EXT_geometry_shader4
-  Standard_Boolean       extBgra;        //!< GL_EXT_bgra or GL_EXT_texture_format_BGRA8888 on OpenGL ES
-  Standard_Boolean       extAnis;        //!< GL_EXT_texture_filter_anisotropic
-  Standard_Boolean       extPDS;         //!< GL_EXT_packed_depth_stencil
-  Standard_Boolean       atiMem;         //!< GL_ATI_meminfo
-  Standard_Boolean       nvxMem;         //!< GL_NVX_gpu_memory_info
+  Standard_Boolean       hasHighp;        //!< highp in GLSL ES fragment shader is supported
+  Standard_Boolean       hasUintIndex;    //!< GLuint for index buffer is supported (always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_element_index_uint)
+  Standard_Boolean       hasTexRGBA8;     //!< always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_rgb8_rgba8
+  Standard_Boolean       arbNPTW;         //!< GL_ARB_texture_non_power_of_two
+  Standard_Boolean       arbTexRG;        //!< GL_ARB_texture_rg
+  Standard_Boolean       arbTexFloat;     //!< GL_ARB_texture_float (on desktop OpenGL - since 3.0 or as extension GL_ARB_texture_float; on OpenGL ES - since 3.0)
+  Standard_Boolean       arbTexHalfFloat; //!< GL_ARB_half_float_pixel (on desktop OpenGL - since 3.0 or as extension GL_ARB_half_float_pixel; on OpenGL ES - since 3.0 or as extension GL_OES_texture_half_float)
+  Standard_Boolean       arbSampleShading;//!< GL_ARB_sample_shading
+  OpenGl_ArbTexBindless* arbTexBindless;  //!< GL_ARB_bindless_texture
+  OpenGl_ArbTBO*         arbTBO;          //!< GL_ARB_texture_buffer_object
+  Standard_Boolean       arbTboRGB32;     //!< GL_ARB_texture_buffer_object_rgb32 (3-component TBO), in core since 4.0
+  OpenGl_ArbIns*         arbIns;          //!< GL_ARB_draw_instanced
+  OpenGl_ArbDbg*         arbDbg;          //!< GL_ARB_debug_output
+  OpenGl_ArbFBO*         arbFBO;          //!< GL_ARB_framebuffer_object
+  OpenGl_ArbFBOBlit*     arbFBOBlit;      //!< glBlitFramebuffer function, moved out from OpenGl_ArbFBO structure for compatibility with OpenGL ES 2.0
+  Standard_Boolean       extFragDepth;    //!< GL_EXT_frag_depth on OpenGL ES 2.0 (gl_FragDepthEXT built-in variable, before OpenGL ES 3.0)
+  OpenGl_ExtGS*          extGS;           //!< GL_EXT_geometry_shader4
+  Standard_Boolean       extBgra;         //!< GL_EXT_bgra or GL_EXT_texture_format_BGRA8888 on OpenGL ES
+  Standard_Boolean       extAnis;         //!< GL_EXT_texture_filter_anisotropic
+  Standard_Boolean       extPDS;          //!< GL_EXT_packed_depth_stencil
+  Standard_Boolean       atiMem;          //!< GL_ATI_meminfo
+  Standard_Boolean       nvxMem;          //!< GL_NVX_gpu_memory_info
 
 public: //! @name public properties tracking current state
 
@@ -777,6 +794,7 @@ private: // context info
   typedef NCollection_Shared< NCollection_DataMap<TCollection_AsciiString, Standard_Integer> > OpenGl_DelayReleaseMap;
   typedef NCollection_Shared< NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)> > OpenGl_ResourcesMap;
   typedef NCollection_Shared< NCollection_List<Handle(OpenGl_Resource)> > OpenGl_ResourcesStack;
+  typedef NCollection_SparseArray<Standard_Integer> OpenGl_DrawBuffers;
 
   Handle(OpenGl_ResourcesMap)    mySharedResources; //!< shared resources with unique identification key
   Handle(OpenGl_DelayReleaseMap) myDelayed;         //!< shared resources for delayed release
@@ -792,6 +810,7 @@ private: // context info
   Standard_Integer myMaxTexDim;            //!< value for GL_MAX_TEXTURE_SIZE
   Standard_Integer myMaxClipPlanes;        //!< value for GL_MAX_CLIP_PLANES
   Standard_Integer myMaxMsaaSamples;       //!< value for GL_MAX_SAMPLES
+  Standard_Integer myMaxDrawBuffers;       //!< value for GL_MAX_DRAW_BUFFERS
   Standard_Integer myGlVerMajor;           //!< cached GL version major number
   Standard_Integer myGlVerMinor;           //!< cached GL version minor number
   Standard_Boolean myIsInitialized;        //!< flag indicates initialization state
@@ -799,6 +818,7 @@ private: // context info
   Standard_Boolean myIsGlNormalizeEnabled; //!< GL_NORMALIZE flag
                                            //!< Used to tell OpenGl that normals should be normalized
 
+  Standard_Boolean myHasHalfFloatTextures;          //! indicates whether half-float textures are supported
   Standard_Boolean myHasRayTracing;                 //! indicates whether ray tracing mode is supported 
   Standard_Boolean myHasRayTracingTextures;         //! indicates whether textures in ray tracing mode are supported 
   Standard_Boolean myHasRayTracingAdaptiveSampling; //! indicates whether adaptive screen sampling in ray tracing mode is supported 
@@ -817,7 +837,7 @@ private: //! @name fields tracking current state
   Standard_Integer              myPolygonMode;     //!< currently used polygon rasterization mode (glPolygonMode)
   bool                          myToCullBackFaces; //!< back face culling mode enabled state (glIsEnabled (GL_CULL_FACE))
   Standard_Integer              myReadBuffer;      //!< current read buffer
-  Standard_Integer              myDrawBuffer;      //!< current draw buffer
+  OpenGl_DrawBuffers            myDrawBuffers;     //!< current draw buffers
   unsigned int                  myDefaultVao;      //!< default Vertex Array Object
   Standard_Boolean              myIsGlDebugCtx;    //!< debug context initialization state
   TCollection_AsciiString       myVendor;          //!< Graphics Driver's vendor

src/OpenGl/OpenGl_Element.hxx

@@ -68,7 +68,7 @@ public:
     RenderFiltered (const Handle(OpenGl_Workspace)& theWorkspace,
                     const Handle(OpenGl_RenderFilter)& theFilter) const
   {
-    if (!theFilter.IsNull() && !theFilter->CanRender (this))
+    if (!theFilter.IsNull() && !theFilter->ShouldRender (theWorkspace, this))
     {
       return Standard_False;
     }

src/OpenGl/OpenGl_FrameBuffer.cxx

@@ -18,6 +18,8 @@
 #include <Standard_Assert.hxx>
 #include <TCollection_ExtendedString.hxx>
 
+#include <algorithm>
+
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_FrameBuffer,OpenGl_Resource)
 
 namespace
@@ -64,6 +66,68 @@ namespace
     return false;
   }
 
+  //! Determine data type from texture sized format.
+  static bool getColorDataFormat (GLint   theTextFormat,
+                                  GLenum& thePixelFormat,
+                                  GLenum& theDataType)
+  {
+    switch (theTextFormat)
+    {
+      case GL_RGBA32F:
+      {
+        thePixelFormat = GL_RGBA;
+        theDataType    = GL_FLOAT;
+        return true;
+      }
+      case GL_R32F:
+      {
+        thePixelFormat = GL_RED;
+        theDataType    = GL_FLOAT;
+        return true;
+      }
+      case GL_RGBA16F:
+      {
+        thePixelFormat = GL_RGBA;
+        theDataType    = GL_HALF_FLOAT;
+        return true;
+      }
+      case GL_R16F:
+      {
+        thePixelFormat = GL_RED;
+        theDataType    = GL_HALF_FLOAT;
+        return true;
+      }
+      case GL_RGBA8:
+      {
+        thePixelFormat = GL_RGBA;
+        theDataType    = GL_UNSIGNED_INT;
+        return true;
+      }
+      case GL_RGBA:
+      {
+        thePixelFormat = GL_RGBA;
+        theDataType    = GL_UNSIGNED_BYTE;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  //! Checks whether two format arrays are equal or not.
+  static bool operator== (const OpenGl_ColorFormats& theFmt1,
+                          const OpenGl_ColorFormats& theFmt2)
+  {
+    if (theFmt1.Length() != theFmt2.Length())
+      return false;
+    OpenGl_ColorFormats::Iterator anIt1 (theFmt1);
+    OpenGl_ColorFormats::Iterator anIt2 (theFmt1);
+    for (; anIt1.More(); anIt1.Next(), anIt2.Next())
+    {
+      if (anIt1.Value() != anIt2.Value())
+        return false;
+    }
+    return true;
+  }
 }
 
 // =======================================================================
@@ -74,16 +138,16 @@ OpenGl_FrameBuffer::OpenGl_FrameBuffer()
 : myVPSizeX (0),
   myVPSizeY (0),
   myNbSamples (0),
-  myColorFormat (GL_RGBA8),
   myDepthFormat (GL_DEPTH24_STENCIL8),
   myGlFBufferId (NO_FRAMEBUFFER),
   myGlColorRBufferId (NO_RENDERBUFFER),
   myGlDepthRBufferId (NO_RENDERBUFFER),
   myIsOwnBuffer  (false),
-  myColorTexture (new OpenGl_Texture()),
+  myIsOwnDepth   (false),
   myDepthStencilTexture (new OpenGl_Texture())
 {
-  //
+  myColorFormats.Append (GL_RGBA8);
+  myColorTextures.Append (new OpenGl_Texture());
 }
 
 // =======================================================================
@@ -100,15 +164,49 @@ OpenGl_FrameBuffer::~OpenGl_FrameBuffer()
 // purpose  :
 // =======================================================================
 Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
-                                           const GLsizei   theSizeX,
-                                           const GLsizei   theSizeY,
-                                           const GLint     theColorFormat,
-                                           const GLint     theDepthFormat,
-                                           const GLsizei   theNbSamples)
+                                           const GLsizei                 theSizeX,
+                                           const GLsizei                 theSizeY,
+                                           const GLint                   theColorFormat,
+                                           const GLint                   theDepthFormat,
+                                           const GLsizei                 theNbSamples)
 {
-  myColorFormat = theColorFormat;
-  myDepthFormat = theDepthFormat;
-  myNbSamples   = theNbSamples;
+  OpenGl_ColorFormats aColorFormats;
+
+  aColorFormats.Append (theColorFormat);
+
+  return Init (theGlContext, theSizeX, theSizeY, aColorFormats, theDepthFormat, theNbSamples);
+}
+
+// =======================================================================
+// function : Init
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
+                                           const GLsizei                 theSizeX,
+                                           const GLsizei                 theSizeY,
+                                           const OpenGl_ColorFormats&    theColorFormats,
+                                           const Handle(OpenGl_Texture)& theDepthStencilTexture,
+                                           const GLsizei                 theNbSamples)
+{
+  myColorFormats = theColorFormats;
+
+  OpenGl_TextureArray aTextures (myColorTextures);
+  if (!myColorTextures.IsEmpty())
+  {
+    OpenGl_TextureArray::Iterator aTextureIt (myColorTextures);
+    for (; aTextureIt.More(); aTextureIt.Next())
+    {
+      aTextureIt.Value()->Release (theGlContext.operator->());
+    }
+    myColorTextures.Clear();
+  }
+  for (Standard_Integer aLength = 0; aLength < myColorFormats.Length(); ++aLength)
+  {
+    myColorTextures.Append (aLength < aTextures.Length() ? aTextures.Value (aLength) : new OpenGl_Texture());
+  }
+
+  myDepthFormat         = theDepthStencilTexture->GetFormat();
+  myNbSamples           = theNbSamples;
   if (theGlContext->arbFBO == NULL)
   {
     return Standard_False;
@@ -116,12 +214,14 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
 
   // clean up previous state
   Release (theGlContext.operator->());
-  if (myColorFormat == 0
+  if (std::count (myColorFormats.begin(), myColorFormats.end(), 0) == myColorFormats.Length()
    && myDepthFormat == 0)
   {
     return Standard_False;
   }
 
+  myDepthStencilTexture = theDepthStencilTexture;
+  myIsOwnDepth  = false;
   myIsOwnBuffer = true;
 
   // setup viewport sizes as is
@@ -133,63 +233,54 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
   // Create the textures (will be used as color buffer and depth-stencil buffer)
   if (theNbSamples != 0)
   {
-    if (myColorFormat != 0
-    && !myColorTexture       ->Init2DMultisample (theGlContext, theNbSamples, myColorFormat, aSizeX, aSizeY))
+    for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
     {
-      Release (theGlContext.operator->());
-      return Standard_False;
-    }
-    if (myDepthFormat != 0
-    && !myDepthStencilTexture->Init2DMultisample (theGlContext, theNbSamples, myDepthFormat, aSizeX, aSizeY))
-    {
-      Release (theGlContext.operator->());
-      return Standard_False;
+      const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+      const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
+      if (aColorFormat != 0
+      && !aColorTexture->Init2DMultisample (theGlContext, theNbSamples,
+                                            aColorFormat, aSizeX, aSizeY))
+      {
+        Release (theGlContext.operator->());
+        return Standard_False;
+      }
     }
   }
   else
   {
-    if (myColorFormat != 0
-    && !myColorTexture->Init (theGlContext, myColorFormat,
-                              GL_RGBA, GL_UNSIGNED_BYTE,
-                              aSizeX, aSizeY, Graphic3d_TOT_2D))
-    {
-      Release (theGlContext.operator->());
-      return Standard_False;
-    }
-
-    // extensions (GL_OES_packed_depth_stencil, GL_OES_depth_texture) + GL version might be used to determine supported formats
-    // instead of just trying to create such texture
     GLenum aPixelFormat = 0;
     GLenum aDataType    = 0;
-    if (myDepthFormat != 0
-    &&  getDepthDataFormat (myDepthFormat, aPixelFormat, aDataType)
-    && !myDepthStencilTexture->Init (theGlContext, myDepthFormat,
-                                      aPixelFormat, aDataType,
-                                      aSizeX, aSizeY, Graphic3d_TOT_2D))
+    for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
     {
-      TCollection_ExtendedString aMsg = TCollection_ExtendedString()
-        + "Warning! Depth textures are not supported by hardware!";
-      theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
-                                 GL_DEBUG_TYPE_PORTABILITY,
-                                 0,
-                                 GL_DEBUG_SEVERITY_HIGH,
-                                 aMsg);
-
-      theGlContext->arbFBO->glGenRenderbuffers (1, &myGlDepthRBufferId);
-      theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlDepthRBufferId);
-      theGlContext->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, aSizeX, aSizeY);
-      theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, NO_RENDERBUFFER);
+      const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+      const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
+      if (aColorFormat != 0
+      &&  getColorDataFormat (aColorFormat, aPixelFormat, aDataType)
+      && !aColorTexture->Init (theGlContext, aColorFormat,
+                               aPixelFormat, aDataType,
+                               aSizeX, aSizeY, Graphic3d_TOT_2D))
+      {
+        Release (theGlContext.operator->());
+        return Standard_False;
+      }
     }
   }
 
   // Build FBO and setup it as texture
   theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
   theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
-  if (myColorTexture->IsValid())
+
+  for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
   {
-    theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                                                  myColorTexture->GetTarget(), myColorTexture->TextureId(), 0);
+    const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+
+    if (aColorTexture->IsValid())
+    {
+      theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + aColorBufferIdx,
+                                                    aColorTexture->GetTarget(), aColorTexture->TextureId(), 0);
+    }
   }
+
   if (myDepthStencilTexture->IsValid())
   {
   #ifdef GL_DEPTH_STENCIL_ATTACHMENT
@@ -221,6 +312,164 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
 // function : Init
 // purpose  :
 // =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
+                                           const GLsizei                 theSizeX,
+                                           const GLsizei                 theSizeY,
+                                           const OpenGl_ColorFormats&    theColorFormats,
+                                           const GLint                   theDepthFormat,
+                                           const GLsizei                 theNbSamples)
+{
+  myColorFormats = theColorFormats;
+
+  OpenGl_TextureArray aTextures (myColorTextures);
+  if (!myColorTextures.IsEmpty())
+  {
+    OpenGl_TextureArray::Iterator aTextureIt (myColorTextures);
+    for (; aTextureIt.More(); aTextureIt.Next())
+    {
+      aTextureIt.Value()->Release (theGlContext.operator->());
+    }
+    myColorTextures.Clear();
+  }
+  for (Standard_Integer aLength = 0; aLength < myColorFormats.Length(); ++aLength)
+  {
+    myColorTextures.Append (aLength < aTextures.Length() ? aTextures.Value (aLength) : new OpenGl_Texture());
+  }
+
+  myDepthFormat  = theDepthFormat;
+  myNbSamples    = theNbSamples;
+  if (theGlContext->arbFBO == NULL)
+  {
+    return Standard_False;
+  }
+
+  // clean up previous state
+  Release (theGlContext.operator->());
+  if (std::count (myColorFormats.begin(), myColorFormats.end(), 0) == myColorFormats.Length()
+   && myDepthFormat == 0)
+  {
+    return Standard_False;
+  }
+
+  myIsOwnBuffer = true;
+  myIsOwnDepth  = true;
+
+  // setup viewport sizes as is
+  myVPSizeX = theSizeX;
+  myVPSizeY = theSizeY;
+  const Standard_Integer aSizeX = theSizeX > 0 ? theSizeX : 2;
+  const Standard_Integer aSizeY = theSizeY > 0 ? theSizeY : 2;
+
+  // Create the textures (will be used as color buffer and depth-stencil buffer)
+  if (theNbSamples != 0)
+  {
+    for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+    {
+      const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+      const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
+      if (aColorFormat != 0
+      && !aColorTexture->Init2DMultisample (theGlContext, theNbSamples,
+                                            aColorFormat, aSizeX, aSizeY))
+      {
+        Release (theGlContext.operator->());
+        return Standard_False;
+      }
+    }
+    if (myDepthFormat != 0
+    && !myDepthStencilTexture->Init2DMultisample (theGlContext, theNbSamples, myDepthFormat, aSizeX, aSizeY))
+    {
+      Release (theGlContext.operator->());
+      return Standard_False;
+    }
+  }
+  else
+  {
+    GLenum aPixelFormat = 0;
+    GLenum aDataType    = 0;
+    for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+    {
+      const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+      const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
+      if (aColorFormat != 0
+      &&  getColorDataFormat (aColorFormat, aPixelFormat, aDataType)
+      && !aColorTexture->Init (theGlContext, aColorFormat,
+                               aPixelFormat, aDataType,
+                               aSizeX, aSizeY, Graphic3d_TOT_2D))
+      {
+        Release (theGlContext.operator->());
+        return Standard_False;
+      }
+    }
+
+    // extensions (GL_OES_packed_depth_stencil, GL_OES_depth_texture) + GL version might be used to determine supported formats
+    // instead of just trying to create such texture
+    if (myDepthFormat != 0
+    &&  getDepthDataFormat (myDepthFormat, aPixelFormat, aDataType)
+    && !myDepthStencilTexture->Init (theGlContext, myDepthFormat,
+                                      aPixelFormat, aDataType,
+                                      aSizeX, aSizeY, Graphic3d_TOT_2D))
+    {
+      TCollection_ExtendedString aMsg = TCollection_ExtendedString()
+        + "Warning! Depth textures are not supported by hardware!";
+      theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+                                 GL_DEBUG_TYPE_PORTABILITY,
+                                 0,
+                                 GL_DEBUG_SEVERITY_HIGH,
+                                 aMsg);
+
+      theGlContext->arbFBO->glGenRenderbuffers (1, &myGlDepthRBufferId);
+      theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlDepthRBufferId);
+      theGlContext->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, aSizeX, aSizeY);
+      theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, NO_RENDERBUFFER);
+    }
+  }
+
+  // Build FBO and setup it as texture
+  theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
+  theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
+
+  for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+  {
+    const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+
+    if (aColorTexture->IsValid())
+    {
+      theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + aColorBufferIdx,
+                                                    aColorTexture->GetTarget(), aColorTexture->TextureId(), 0);
+    }
+  }
+
+  if (myDepthStencilTexture->IsValid())
+  {
+  #ifdef GL_DEPTH_STENCIL_ATTACHMENT
+    theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                                  myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
+  #else
+    theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                                  myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
+    theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
+                                                  myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
+  #endif
+  }
+  else if (myGlDepthRBufferId != NO_RENDERBUFFER)
+  {
+    theGlContext->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                                     GL_RENDERBUFFER, myGlDepthRBufferId);
+  }
+  if (theGlContext->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+  {
+    Release (theGlContext.operator->());
+    return Standard_False;
+  }
+
+  UnbindBuffer (theGlContext);
+  return Standard_True;
+}
+
+// =======================================================================
+// function : InitLazy
+// purpose  :
+// =======================================================================
 Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlContext,
                                                const GLsizei                 theViewportSizeX,
                                                const GLsizei                 theViewportSizeY,
@@ -228,16 +477,44 @@ Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& the
                                                const GLint                   theDepthFormat,
                                                const GLsizei                 theNbSamples)
 {
-  if (myVPSizeX     == theViewportSizeX
-   && myVPSizeY     == theViewportSizeY
-   && myColorFormat == theColorFormat
-   && myDepthFormat == theDepthFormat
-   && myNbSamples   == theNbSamples)
+  OpenGl_ColorFormats aColorFormats;
+
+  aColorFormats.Append (theColorFormat);
+
+  return InitLazy (theGlContext, theViewportSizeX, theViewportSizeY, aColorFormats, theDepthFormat, theNbSamples);
+}
+
+// =======================================================================
+// function : InitLazy
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlContext,
+                                               const GLsizei                 theViewportSizeX,
+                                               const GLsizei                 theViewportSizeY,
+                                               const OpenGl_ColorFormats&    theColorFormats,
+                                               const GLint                   theDepthFormat,
+                                               const GLsizei                 theNbSamples)
+{
+  if (myVPSizeX      == theViewportSizeX
+   && myVPSizeY      == theViewportSizeY
+   && myColorFormats == theColorFormats
+   && myDepthFormat  == theDepthFormat
+   && myNbSamples    == theNbSamples)
   {
     return IsValid();
   }
 
-  return Init (theGlContext, theViewportSizeX, theViewportSizeY, theColorFormat, theDepthFormat, theNbSamples);
+  return Init (theGlContext, theViewportSizeX, theViewportSizeY, theColorFormats, theDepthFormat, theNbSamples);
+}
+
+// =======================================================================
+// function : InitLazy
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlCtx,
+                                               const OpenGl_FrameBuffer&     theFbo)
+{
+  return InitLazy (theGlCtx, theFbo.myVPSizeX, theFbo.myVPSizeY, theFbo.myColorFormats, theFbo.myDepthFormat, theFbo.myNbSamples);
 }
 
 // =======================================================================
@@ -251,9 +528,22 @@ Standard_Boolean OpenGl_FrameBuffer::InitWithRB (const Handle(OpenGl_Context)& t
                                                  const GLint                   theDepthFormat,
                                                  const GLuint                  theColorRBufferFromWindow)
 {
-  myColorFormat = theColorFormat;
-  myDepthFormat = theDepthFormat;
-  myNbSamples   = 0;
+  myColorFormats.Clear();
+  myColorFormats.Append (theColorFormat);
+  if (!myColorTextures.IsEmpty())
+  {
+    Handle(OpenGl_Texture) aTexutre = myColorTextures.First();
+    OpenGl_TextureArray::Iterator aTextureIt (myColorTextures);
+    for (; aTextureIt.More(); aTextureIt.Next())
+    {
+      aTextureIt.Value()->Release (theGlCtx.operator->());
+    }
+    myColorTextures.Clear();
+    myColorTextures.Append (aTexutre);
+  }
+
+  myDepthFormat  = theDepthFormat;
+  myNbSamples    = 0;
   if (theGlCtx->arbFBO == NULL)
   {
     return Standard_False;
@@ -263,6 +553,7 @@ Standard_Boolean OpenGl_FrameBuffer::InitWithRB (const Handle(OpenGl_Context)& t
   Release (theGlCtx.operator->());
 
   myIsOwnBuffer = true;
+  myIsOwnDepth  = true;
 
   // setup viewport sizes as is
   myVPSizeX = theSizeX;
@@ -275,11 +566,11 @@ Standard_Boolean OpenGl_FrameBuffer::InitWithRB (const Handle(OpenGl_Context)& t
   {
     myGlColorRBufferId = theColorRBufferFromWindow;
   }
-  else if (myColorFormat != 0)
+  else if (theColorFormat != 0)
   {
     theGlCtx->arbFBO->glGenRenderbuffers (1, &myGlColorRBufferId);
     theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlColorRBufferId);
-    theGlCtx->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, myColorFormat, aSizeX, aSizeY);
+    theGlCtx->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, theColorFormat, aSizeX, aSizeY);
   }
 
   if (myDepthFormat != 0)
@@ -344,17 +635,19 @@ Standard_Boolean OpenGl_FrameBuffer::InitWrapper (const Handle(OpenGl_Context)&
   GLint aColorId   = 0;
   GLint aDepthType = 0;
   GLint aDepthId   = 0;
+
   theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &aColorType);
   theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &aDepthType);
 
   myGlFBufferId = GLuint(anFbo);
   myIsOwnBuffer = false;
+  myIsOwnDepth  = false;
   if (aColorType == GL_RENDERBUFFER)
   {
     theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &aColorId);
     myGlColorRBufferId = aColorId;
   }
-  else if (aColorType != GL_NONE)
+  else if (aColorType != 0)
   {
     TCollection_ExtendedString aMsg = "OpenGl_FrameBuffer::InitWrapper(), color attachment of unsupported type has been skipped!";
     theGlCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
@@ -369,7 +662,7 @@ Standard_Boolean OpenGl_FrameBuffer::InitWrapper (const Handle(OpenGl_Context)&
     theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &aDepthId);
     myGlDepthRBufferId = aDepthId;
   }
-  else if (aDepthType != GL_NONE)
+  else if (aDepthType != 0)
   {
     TCollection_ExtendedString aMsg = "OpenGl_FrameBuffer::InitWrapper(), depth attachment of unsupported type has been skipped!";
     theGlCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
@@ -422,8 +715,17 @@ void OpenGl_FrameBuffer::Release (OpenGl_Context* theGlCtx)
     myIsOwnBuffer      = false;
   }
 
-  myColorTexture->Release (theGlCtx);
-  myDepthStencilTexture->Release (theGlCtx);
+  for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < NbColorBuffers(); ++aColorBufferIdx)
+  {
+    myColorTextures (aColorBufferIdx)->Release (theGlCtx);
+  }
+
+  if (myIsOwnDepth)
+  {
+    myDepthStencilTexture->Release (theGlCtx);
+
+    myIsOwnDepth = false;
+  }
 
   myVPSizeX = 0;
   myVPSizeY = 0;

src/OpenGl/OpenGl_FrameBuffer.hxx

@@ -19,14 +19,18 @@
 #include <OpenGl_Resource.hxx>
 #include <OpenGl_Texture.hxx>
 
+#include <NCollection_Vector.hxx>
+
 class OpenGl_FrameBuffer;
 DEFINE_STANDARD_HANDLE(OpenGl_FrameBuffer, OpenGl_Resource)
 
+//! Short declaration of useful collection types.
+typedef NCollection_Vector<GLint> OpenGl_ColorFormats;
+
 //! Class implements FrameBuffer Object (FBO) resource
 //! intended for off-screen rendering.
 class OpenGl_FrameBuffer : public OpenGl_Resource
 {
-
 public:
 
   //! Helpful constants
@@ -35,7 +39,7 @@ public:
 
 public:
 
-  //! Empty constructor
+  //! Constructor.
   Standard_EXPORT OpenGl_FrameBuffer();
 
   //! Destructor
@@ -50,10 +54,16 @@ public:
     return myNbSamples;
   }
 
-  //! Return true if FBO has been created with color attachment.
-  bool HasColor() const
+  //! Number of color buffers.
+  GLsizei NbColorBuffers() const
   {
-    return myColorFormat != 0;
+    return myColorTextures.Length();
+  }
+
+  //! Return true if FBO has been created with color attachment.
+  bool HasColor (const GLint theColorBufferIdx = 0) const
+  {
+    return myColorFormats (theColorBufferIdx) != 0;
   }
 
   //! Return true if FBO has been created with depth attachment.
@@ -65,13 +75,13 @@ public:
   //! Textures width.
   GLsizei GetSizeX() const
   {
-    return myColorTexture->SizeX();
+    return myColorTextures (0)->SizeX();
   }
 
   //! Textures height.
   GLsizei GetSizeY() const
   {
-    return myColorTexture->SizeY();
+    return myColorTextures (0)->SizeY();
   }
 
   //! Viewport width.
@@ -92,13 +102,20 @@ public:
     return isValidFrameBuffer();
   }
 
+  Standard_EXPORT Standard_Boolean Init (const Handle(OpenGl_Context)& theGlCtx,
+                                         const GLsizei                 theSizeX,
+                                         const GLsizei                 theSizeY,
+                                         const OpenGl_ColorFormats&    theColorFormats,
+                                         const Handle(OpenGl_Texture)& theDepthStencilTexture,
+                                         const GLsizei                 theNbSamples = 0);
+
   //! Initialize FBO for rendering into textures.
-  //! @param theGlCtx       currently bound OpenGL context
-  //! @param theSizeX       texture width
-  //! @param theSizeY       texture height
-  //! @param theColorFormat color         texture sized format (0 means no color attachment), e.g. GL_RGBA8
-  //! @param theDepthFormat depth-stencil texture sized format (0 means no depth attachment), e.g. GL_DEPTH24_STENCIL8
-  //! @param theNbSamples   MSAA number of samples (0 means normal texture)
+  //! @param theGlCtx        currently bound OpenGL context
+  //! @param theSizeX        texture width
+  //! @param theSizeY        texture height
+  //! @param theColorFormat  color         texture sized format (0 means no color attachment), e.g. GL_RGBA8
+  //! @param theDepthFormat  depth-stencil texture sized format (0 means no depth attachment), e.g. GL_DEPTH24_STENCIL8
+  //! @param theNbSamples    MSAA number of samples (0 means normal texture)
   //! @return true on success
   Standard_EXPORT Standard_Boolean Init (const Handle(OpenGl_Context)& theGlCtx,
                                          const GLsizei                 theSizeX,
@@ -107,6 +124,21 @@ public:
                                          const GLint                   theDepthFormat,
                                          const GLsizei                 theNbSamples = 0);
 
+  //! Initialize FBO for rendering into textures.
+  //! @param theGlCtx        currently bound OpenGL context
+  //! @param theSizeX        texture width
+  //! @param theSizeY        texture height
+  //! @param theColorFormats color         texture sized format (0 means no color attachment), e.g. GL_RGBA8
+  //! @param theDepthFormat  depth-stencil texture sized format (0 means no depth attachment), e.g. GL_DEPTH24_STENCIL8
+  //! @param theNbSamples    MSAA number of samples (0 means normal texture)
+  //! @return true on success
+  Standard_EXPORT Standard_Boolean Init (const Handle(OpenGl_Context)& theGlCtx,
+                                         const GLsizei                 theSizeX,
+                                         const GLsizei                 theSizeY,
+                                         const OpenGl_ColorFormats&    theColorFormats,
+                                         const GLint                   theDepthFormat,
+                                         const GLsizei                 theNbSamples = 0);
+
   //! (Re-)initialize FBO with specified dimensions.
   Standard_EXPORT Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
                                              const GLsizei                 theViewportSizeX,
@@ -115,20 +147,25 @@ public:
                                              const GLint                   theDepthFormat,
                                              const GLsizei                 theNbSamples = 0);
 
+  //! (Re-)initialize FBO with specified dimensions.
+  Standard_EXPORT Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
+                                             const GLsizei                 theViewportSizeX,
+                                             const GLsizei                 theViewportSizeY,
+                                             const OpenGl_ColorFormats&    theColorFormats,
+                                             const GLint                   theDepthFormat,
+                                             const GLsizei                 theNbSamples = 0);
+
   //! (Re-)initialize FBO with properties taken from another FBO.
-  Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
-                             const OpenGl_FrameBuffer&     theFbo)
-  {
-    return InitLazy (theGlCtx, theFbo.myVPSizeX, theFbo.myVPSizeY, theFbo.myColorFormat, theFbo.myDepthFormat, theFbo.myNbSamples);
-  }
+  Standard_EXPORT Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
+                                             const OpenGl_FrameBuffer&     theFbo);
 
   //! (Re-)initialize FBO with specified dimensions.
   //! The Render Buffer Objects will be used for Color, Depth and Stencil attachments (as opposite to textures).
-  //! @param theGlCtx       currently bound OpenGL context
-  //! @param theSizeX       render buffer width
-  //! @param theSizeY       render buffer height
-  //! @param theColorFormat color         render buffer sized format, e.g. GL_RGBA8
-  //! @param theDepthFormat depth-stencil render buffer sized format, e.g. GL_DEPTH24_STENCIL8
+  //! @param theGlCtx        currently bound OpenGL context
+  //! @param theSizeX        render buffer width
+  //! @param theSizeY        render buffer height
+  //! @param theColorFormat  color         render buffer sized format, e.g. GL_RGBA8
+  //! @param theDepthFormat  depth-stencil render buffer sized format, e.g. GL_DEPTH24_STENCIL8
   //! @param theColorRBufferFromWindow when specified - should be ID of already initialized RB object, which will be released within this class
   Standard_EXPORT Standard_Boolean InitWithRB (const Handle(OpenGl_Context)& theGlCtx,
                                                const GLsizei                 theSizeX,
@@ -161,9 +198,9 @@ public:
   Standard_EXPORT virtual void UnbindBuffer (const Handle(OpenGl_Context)& theGlCtx);
 
   //! Returns the color texture.
-  inline const Handle(OpenGl_Texture)& ColorTexture() const
+  inline const Handle(OpenGl_Texture)& ColorTexture (const GLint theColorBufferIdx = 0) const
   {
-    return myColorTexture;
+    return myColorTextures (theColorBufferIdx);
   }
 
   //! Returns the depth-stencil texture.
@@ -193,16 +230,19 @@ protected:
 
 protected:
 
+  typedef NCollection_Vector<Handle(OpenGl_Texture)> OpenGl_TextureArray;
+
   GLsizei                myVPSizeX;             //!< viewport width  (should be <= texture width)
   GLsizei                myVPSizeY;             //!< viewport height (should be <= texture height)
   GLsizei                myNbSamples;           //!< number of MSAA samples
-  GLint                  myColorFormat;         //!< sized format for color         texture, GL_RGBA8 by default
+  OpenGl_ColorFormats    myColorFormats;        //!< sized format for color         texture, GL_RGBA8 by default
   GLint                  myDepthFormat;         //!< sized format for depth-stencil texture, GL_DEPTH24_STENCIL8 by default
   GLuint                 myGlFBufferId;         //!< FBO object ID
   GLuint                 myGlColorRBufferId;    //!< color         Render Buffer object (alternative to myColorTexture)
   GLuint                 myGlDepthRBufferId;    //!< depth-stencil Render Buffer object (alternative to myDepthStencilTexture)
   bool                   myIsOwnBuffer;         //!< flag indicating that FBO should be deallocated by this class
-  Handle(OpenGl_Texture) myColorTexture;        //!< color texture object
+  bool                   myIsOwnDepth;          //!< flag indicating that FBO should be deallocated by this class
+  OpenGl_TextureArray    myColorTextures;       //!< color texture objects
   Handle(OpenGl_Texture) myDepthStencilTexture; //!< depth-stencil texture object
 
 public:

src/OpenGl/OpenGl_GlFunctions.hxx

@@ -186,6 +186,45 @@
   #define GL_DEBUG_SEVERITY_HIGH        0x9146
   #define GL_DEBUG_SEVERITY_MEDIUM      0x9147
   #define GL_DEBUG_SEVERITY_LOW         0x9148
+
+  // GL_EXT_draw_buffers
+  #define GL_MAX_COLOR_ATTACHMENTS       0x8CDF
+  #define GL_MAX_DRAW_BUFFERS            0x8824
+  #define GL_DRAW_BUFFER0                0x8825
+  #define GL_DRAW_BUFFER1                0x8826
+  #define GL_DRAW_BUFFER2                0x8827
+  #define GL_DRAW_BUFFER3                0x8828
+  #define GL_DRAW_BUFFER4                0x8829
+  #define GL_DRAW_BUFFER5                0x882A
+  #define GL_DRAW_BUFFER6                0x882B
+  #define GL_DRAW_BUFFER7                0x882C
+  #define GL_DRAW_BUFFER8                0x882D
+  #define GL_DRAW_BUFFER9                0x882E
+  #define GL_DRAW_BUFFER10               0x882F
+  #define GL_DRAW_BUFFER11               0x8830
+  #define GL_DRAW_BUFFER12               0x8831
+  #define GL_DRAW_BUFFER13               0x8832
+  #define GL_DRAW_BUFFER14               0x8833
+  #define GL_DRAW_BUFFER15               0x8834
+  #define GL_COLOR_ATTACHMENT0           0x8CE0
+  #define GL_COLOR_ATTACHMENT1           0x8CE1
+  #define GL_COLOR_ATTACHMENT2           0x8CE2
+  #define GL_COLOR_ATTACHMENT3           0x8CE3
+  #define GL_COLOR_ATTACHMENT4           0x8CE4
+  #define GL_COLOR_ATTACHMENT5           0x8CE5
+  #define GL_COLOR_ATTACHMENT6           0x8CE6
+  #define GL_COLOR_ATTACHMENT7           0x8CE7
+  #define GL_COLOR_ATTACHMENT8           0x8CE8
+  #define GL_COLOR_ATTACHMENT9           0x8CE9
+  #define GL_COLOR_ATTACHMENT10          0x8CEA
+  #define GL_COLOR_ATTACHMENT11          0x8CEB
+  #define GL_COLOR_ATTACHMENT12          0x8CEC
+  #define GL_COLOR_ATTACHMENT13          0x8CED
+  #define GL_COLOR_ATTACHMENT14          0x8CEE
+  #define GL_COLOR_ATTACHMENT15          0x8CEF
+
+  // OES_texture_half_float
+  #define GL_HALF_FLOAT                  0x8D61
 #endif
 
 #if !defined(HAVE_EGL) && (defined(__ANDROID__) || defined(__QNX__) || defined(HAVE_GLES2) || defined(OCCT_UWP))
@@ -752,6 +791,9 @@ public: //! @name OpenGL ES 3.0
   typedef void (*glTexImage3D_t)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* data);
   glTexImage3D_t glTexImage3D;
 
+  typedef void (*glDrawBuffers_t)(GLsizei n, const GLenum* bufs);
+  glDrawBuffers_t glDrawBuffers;
+
 public: //! @name OpenGL ES 3.1
 
   typedef void (*glTexStorage2DMultisample_t)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

src/OpenGl/OpenGl_Layer.cxx

@@ -687,7 +687,9 @@ void OpenGl_Layer::Render (const Handle(OpenGl_Workspace)&   theWorkspace,
   theWorkspace->SetPolygonOffset (myLayerSettings.PolygonOffset());
 
   // handle depth write
-  theWorkspace->UseDepthWrite() = myLayerSettings.ToEnableDepthWrite();
+  theWorkspace->UseDepthWrite() = myLayerSettings.ToEnableDepthWrite()
+                               && theDefaultSettings.DepthMask == GL_TRUE;
+
   glDepthMask (theWorkspace->UseDepthWrite() ? GL_TRUE : GL_FALSE);
 
   const Standard_Boolean hasLocalCS = !myLayerSettings.OriginTransformation().IsNull();

src/OpenGl/OpenGl_Layer.hxx

@@ -27,7 +27,6 @@
 #include <Graphic3d_Camera.hxx>
 #include <OpenGl_GlCore11.hxx>
 
-
 struct OpenGl_GlobalLayerSettings
 {
   GLint DepthFunc;

src/OpenGl/OpenGl_LayerList.cxx

@@ -13,10 +13,14 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <OpenGl_GlCore11.hxx>
+#include <OpenGl_GlCore15.hxx>
 
+#include <OpenGl_FrameBuffer.hxx>
 #include <OpenGl_LayerList.hxx>
+#include <OpenGl_ShaderManager.hxx>
 #include <OpenGl_Structure.hxx>
+#include <OpenGl_VertexBuffer.hxx>
+#include <OpenGl_View.hxx>
 #include <OpenGl_Workspace.hxx>
 
 #include <Graphic3d_GraphicDriver.hxx>
@@ -31,7 +35,9 @@ OpenGl_LayerList::OpenGl_LayerList (const Standard_Integer theNbPriorities)
   myNbPriorities (theNbPriorities),
   myNbStructures (0),
   myImmediateNbStructures (0),
-  myModifStateOfRaytraceable (0)
+  myModifStateOfRaytraceable (0),
+  myRenderOpaqueFilter (new OpenGl_OpaqueFilter()),
+  myRenderTranspFilter (new OpenGl_TransparentFilter())
 {
   // insert default priority layers
   myLayers.Append (OpenGl_Layer (myNbPriorities));
@@ -50,6 +56,8 @@ OpenGl_LayerList::OpenGl_LayerList (const Standard_Integer theNbPriorities)
   myLayerIds.Bind (Graphic3d_ZLayerId_TopOSD,  myLayers.Upper());
 
   myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
+
+  myTransparentToProcess.Allocate (myLayers.Length());
 }
 
 //=======================================================================
@@ -76,6 +84,8 @@ void OpenGl_LayerList::AddLayer (const Graphic3d_ZLayerId theLayerId)
   // add the new layer
   myLayers.Append (OpenGl_Layer (myNbPriorities));
   myLayerIds.Bind (theLayerId, myLayers.Length());
+
+  myTransparentToProcess.Allocate (myLayers.Length());
 }
 
 //=======================================================================
@@ -128,6 +138,8 @@ void OpenGl_LayerList::RemoveLayer (const Graphic3d_ZLayerId theLayerId)
   }
 
   myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
+
+  myTransparentToProcess.Allocate (myLayers.Length());
 }
 
 //=======================================================================
@@ -378,17 +390,39 @@ void OpenGl_LayerList::SetLayerSettings (const Graphic3d_ZLayerId        theLaye
 //=======================================================================
 void OpenGl_LayerList::Render (const Handle(OpenGl_Workspace)& theWorkspace,
                                const Standard_Boolean          theToDrawImmediate,
-                               const OpenGl_LayerFilter        theLayersToProcess) const
+                               const OpenGl_LayerFilter        theLayersToProcess,
+                               OpenGl_FrameBuffer*             theReadDrawFbo,
+                               OpenGl_FrameBuffer*             theOitAccumFbo) const
 {
+  // Remember global settings for glDepth function and write mask.
   OpenGl_GlobalLayerSettings aDefaultSettings;
 
   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
   aCtx->core11fwd->glGetIntegerv (GL_DEPTH_FUNC,      &aDefaultSettings.DepthFunc);
   aCtx->core11fwd->glGetBooleanv (GL_DEPTH_WRITEMASK, &aDefaultSettings.DepthMask);
 
+  // Two render filters are used to support transparency draw. Opaque filter accepts
+  // only non-transparent OpenGl elements of a layer and counts number of skipped
+  // transparent ones. If the counter has positive value the layer is added into
+  // transparency post-processing stack. At the end of drawing or once the depth
+  // buffer is to be cleared the layers in the stack should be drawn using
+  // blending and depth mask settings and another transparency filter which accepts
+  // only transparent OpenGl elements of a layer. The stack <myTransparentToProcess>
+  // was preallocated before going into this method and has enough space to keep
+  // maximum number of references to layers, therefore it will not increase memory
+  // fragmentation during regular rendering.
+  const Handle(OpenGl_RenderFilter) aPrevFilter = theWorkspace->GetRenderFilter();
+  myRenderOpaqueFilter->SetPreviousFilter (aPrevFilter);
+  myRenderTranspFilter->SetPreviousFilter (aPrevFilter);
+  theWorkspace->SetRenderFilter (myRenderOpaqueFilter);
+
+  myTransparentToProcess.Clear();
+
+  OpenGl_LayerStack      ::iterator aStackIter (myTransparentToProcess.Origin());
+  OpenGl_SequenceOfLayers::iterator anIts (myLayers.begin());
   Standard_Integer aSeqId = myLayers.Lower();
-  bool toClearDepth = false;
-  for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next(), ++aSeqId)
+  bool toClearDepth     = false;
+  for (; anIts != myLayers.end(); ++anIts, ++aSeqId)
   {
     if (theLayersToProcess == OpenGl_LF_Bottom)
     {
@@ -403,28 +437,54 @@ void OpenGl_LayerList::Render (const Handle(OpenGl_Workspace)& theWorkspace,
       if (aSeqId != myDefaultLayerIndex) continue;
     }
 
-    const OpenGl_Layer& aLayer = anIts.Value();
+    const OpenGl_Layer& aLayer = (*anIts);
     if (aLayer.IsImmediate() != theToDrawImmediate)
     {
       continue;
     }
     else if (aLayer.NbStructures() < 1)
     {
-      // make sure to clear depth of previous layers even if layer has no structures
+      // Make sure to clear depth of previous layers even if layer has no structures.
       toClearDepth = toClearDepth || aLayer.LayerSettings().ToClearDepth();
       continue;
     }
 
-    // depth buffers
+    // At this point the depth buffer may be set to clear by
+    // previous configuration of layers or configuration of the
+    // current layer. Additional rendering pass to handle transparent
+    // elements of recently drawn layers require use of current depth
+    // buffer so we put remaining layers for processing as one bunch before
+    // erasing the depth buffer.
     if (toClearDepth
      || aLayer.LayerSettings().ToClearDepth())
     {
+      if (!myTransparentToProcess.IsEmpty())
+      {
+        renderTransparent (theWorkspace, aStackIter, aDefaultSettings, theReadDrawFbo, theOitAccumFbo);
+      }
+
       toClearDepth = false;
       glDepthMask (GL_TRUE);
       glClear (GL_DEPTH_BUFFER_BIT);
     }
 
+    // Render opaque OpenGl elements of a layer and count the number of skipped.
+    // If a layer has skipped (e.g. transparent) elements it should be added into
+    // the transparency post-processing stack.
+    myRenderOpaqueFilter->SetSkippedCounter (0);
+
     aLayer.Render (theWorkspace, aDefaultSettings);
+
+    if (myRenderOpaqueFilter->NbSkipped() > 0)
+    {
+      myTransparentToProcess.Push (&aLayer);
+    }
+  }
+
+  // Before finishing process the remaining collected layers with transparency.
+  if (!myTransparentToProcess.IsEmpty())
+  {
+    renderTransparent (theWorkspace, aStackIter, aDefaultSettings, theReadDrawFbo, theOitAccumFbo);
   }
 
   if (toClearDepth)
@@ -435,4 +495,232 @@ void OpenGl_LayerList::Render (const Handle(OpenGl_Workspace)& theWorkspace,
 
   aCtx->core11fwd->glDepthMask (aDefaultSettings.DepthMask);
   aCtx->core11fwd->glDepthFunc (aDefaultSettings.DepthFunc);
+
+  theWorkspace->SetRenderFilter (aPrevFilter);
+}
+
+//=======================================================================
+//function : renderTransparent
+//purpose  : Render transparent objects using blending operator.
+//=======================================================================
+void OpenGl_LayerList::renderTransparent (const Handle(OpenGl_Workspace)&   theWorkspace,
+                                          OpenGl_LayerStack::iterator&      theLayerIter,
+                                          const OpenGl_GlobalLayerSettings& theGlobalSettings,
+                                          OpenGl_FrameBuffer*               theReadDrawFbo,
+                                          OpenGl_FrameBuffer*               theOitAccumFbo) const
+{
+  // Blended order-independent transparency algorithm require several preconditions
+  // to be enabled. It should be requested by user, at least two outputs from
+  // fragment shader should be supported by GPU, so is the given framebuffer
+  // should contain two additional color buffers to handle accumulated color channels,
+  // blended alpha channel and weight factors - these accumulation buffers are required
+  // to implement commuting blend operator (at least OpenGl 2.0 should be available).
+  const bool isEnabledOit = theOitAccumFbo != NULL
+                         && theOitAccumFbo->NbColorBuffers() >= 2
+                         && theOitAccumFbo->ColorTexture (0)->IsValid()
+                         && theOitAccumFbo->ColorTexture (1)->IsValid();
+
+  // Check if current iterator has already reached the end of the stack.
+  // This should happen if no additional layers has been added to
+  // the processing stack after last transparency pass.
+  if (theLayerIter == myTransparentToProcess.Back())
+  {
+    return;
+  }
+
+  const Handle(OpenGl_Context) aCtx            = theWorkspace->GetGlContext();
+  const Handle(OpenGl_ShaderManager)& aManager = aCtx->ShaderManager();
+  const OpenGl_View* aView                     = theWorkspace->View();
+  const float aOitDepthWeight = aView ? aView->RenderingParams().OitDepthWeight : 0.0f;
+
+  theWorkspace->SetRenderFilter (myRenderTranspFilter);
+
+  aCtx->core11fwd->glEnable (GL_BLEND);
+
+  if (isEnabledOit)
+  {
+    aManager->SetOitState (true, aOitDepthWeight);
+
+    theOitAccumFbo->BindBuffer (aCtx);
+
+    static const Standard_Integer aDrawBuffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
+    aCtx->SetDrawBuffers (2, aDrawBuffers);
+    aCtx->core11fwd->glClearColor (0.f, 0.f, 0.f, 1.f);
+    aCtx->core11fwd->glClear (GL_COLOR_BUFFER_BIT);
+    aCtx->core15fwd->glBlendFuncSeparate (GL_ONE, GL_ONE, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
+  }
+  else
+  {
+    aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  }
+
+  // During blended order-independent transparency pass the depth test
+  // should be enabled to discard fragments covered by opaque geometry
+  // and depth writing should be disabled, because transparent fragments
+  // overal each other with non unitary coverage factor.
+  OpenGl_GlobalLayerSettings aGlobalSettings = theGlobalSettings;
+  aGlobalSettings.DepthMask   = GL_FALSE;
+  aCtx->core11fwd->glDepthMask (GL_FALSE);
+
+  for (; theLayerIter != myTransparentToProcess.Back(); ++theLayerIter)
+  {
+    (*theLayerIter)->Render (theWorkspace, aGlobalSettings);
+  }
+
+  // Revert state of rendering.
+  if (isEnabledOit)
+  {
+    aManager->SetOitState (false, aOitDepthWeight);
+
+    theOitAccumFbo->UnbindBuffer (aCtx);
+
+    if (theReadDrawFbo)
+    {
+      theReadDrawFbo->BindBuffer (aCtx);
+    }
+
+    static const Standard_Integer aDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
+
+    aCtx->SetDrawBuffers (1, aDrawBuffers);
+  }
+
+  theWorkspace->SetRenderFilter (myRenderOpaqueFilter);
+
+  if (isEnabledOit)
+  {
+    const Standard_Boolean isMSAA = theReadDrawFbo && theReadDrawFbo->NbSamples() > 0;
+
+    OpenGl_VertexBuffer* aVerts = theWorkspace->View()->initBlitQuad (Standard_False);
+
+    if (aVerts->IsValid() && aManager->BindOitCompositingProgram (isMSAA))
+    {
+      aCtx->core11fwd->glDepthFunc (GL_ALWAYS);
+      aCtx->core11fwd->glDepthMask (GL_FALSE);
+
+      // Bind full screen quad buffer and framebuffer resources.
+      aVerts->BindVertexAttrib (aCtx, Graphic3d_TOA_POS);
+
+      const Handle(OpenGl_Texture) aTextureBack = theWorkspace->DisableTexture();
+
+      theOitAccumFbo->ColorTexture (0)->Bind (aCtx, GL_TEXTURE0 + 0);
+      theOitAccumFbo->ColorTexture (1)->Bind (aCtx, GL_TEXTURE0 + 1);
+
+      // Draw full screen quad with special shader to compose the buffers.
+      aCtx->core11fwd->glBlendFunc (GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
+      aCtx->core11fwd->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
+
+      // Unbind OpenGL texture objects and shader program.
+      aVerts->UnbindVertexAttrib (aCtx, Graphic3d_TOA_POS);
+      theOitAccumFbo->ColorTexture (0)->Unbind (aCtx, GL_TEXTURE0 + 0);
+      theOitAccumFbo->ColorTexture (1)->Unbind (aCtx, GL_TEXTURE0 + 1);
+      aCtx->BindProgram (NULL);
+
+      if (!aTextureBack.IsNull())
+      {
+        theWorkspace->EnableTexture (aTextureBack);
+      }
+    }
+    else
+    {
+      TCollection_ExtendedString aMsg = TCollection_ExtendedString()
+                                      + "Initialization of OIT compositing pass has failed.\n"
+                                      + "  Blended order-independent transparency will not be available.\n";
+      aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+                         GL_DEBUG_TYPE_ERROR,
+                         0,
+                         GL_DEBUG_SEVERITY_HIGH,
+                        aMsg);
+      OpenGl_View* aView = theWorkspace->View();
+      if (aView)
+      {
+        Standard_Boolean& aOITFlag = isMSAA ? aView->myToDisableOITMSAA : aView->myToDisableOIT;
+        aOITFlag = Standard_True;
+      }
+    }
+  }
+
+  aCtx->core11fwd->glDisable (GL_BLEND);
+  aCtx->core11fwd->glBlendFunc (GL_ONE, GL_ZERO);
+  aCtx->core11fwd->glDepthMask (theGlobalSettings.DepthMask);
+  aCtx->core11fwd->glDepthFunc (theGlobalSettings.DepthFunc);
+}
+
+//=======================================================================
+//class    : OpenGl_OpaqueFilter
+//function : ShouldRender
+//purpose  : Checks whether the element should be rendered or skipped.
+//=======================================================================
+Standard_Boolean OpenGl_LayerList::OpenGl_OpaqueFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                                                      const OpenGl_Element*           theGlElement)
+{
+  if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement))
+  {
+    return Standard_False;
+  }
+
+  const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
+  if (aPArray != NULL
+      && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+      && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
+  {
+    const OpenGl_AspectFace* anAspect = theWorkspace->ApplyAspectFace();
+    if (anAspect)
+    {
+      const bool toDistinguish = anAspect->Aspect()->Distinguish();
+      const Graphic3d_MaterialAspect& aMatFrontSrc = anAspect->Aspect()->FrontMaterial();
+      const Graphic3d_MaterialAspect& aMatBackSrc  = toDistinguish
+                                                    ? anAspect->Aspect()->BackMaterial()
+                                                    : aMatFrontSrc;
+
+      const Standard_Size aSkippedCounter  = mySkippedCounter;
+      if (((float)aMatFrontSrc.Transparency() > ShortRealEpsilon())
+       || ((float)aMatBackSrc .Transparency() > ShortRealEpsilon()))
+      {
+        mySkippedCounter++;
+      }
+
+      return mySkippedCounter == aSkippedCounter;
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//class    : OpenGl_TransparentFilter
+//function : ShouldRender
+//purpose  : Checks whether the element should be rendered or skipped.
+//=======================================================================
+Standard_Boolean OpenGl_LayerList::OpenGl_TransparentFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                                                           const OpenGl_Element*           theGlElement)
+{
+  if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement))
+  {
+    return Standard_False;
+  }
+
+  const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
+  if (aPArray != NULL
+      && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+      && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
+  {
+    const OpenGl_AspectFace* anAspect = theWorkspace->ApplyAspectFace();
+    if (anAspect)
+    {
+      const bool toDistinguish = anAspect->Aspect()->Distinguish();
+      const Graphic3d_MaterialAspect& aMatFrontSrc = anAspect->Aspect()->FrontMaterial();
+      const Graphic3d_MaterialAspect& aMatBackSrc  = toDistinguish
+                                                    ? anAspect->Aspect()->BackMaterial()
+                                                    : aMatFrontSrc;
+
+      return ((float)aMatFrontSrc.Transparency() > ShortRealEpsilon())
+          || ((float)aMatBackSrc .Transparency() > ShortRealEpsilon());
+    }
+  }
+  else
+  {
+    return dynamic_cast<const OpenGl_AspectFace*> (theGlElement) != NULL;
+  }
+
+  return Standard_False;
 }

src/OpenGl/OpenGl_LayerList.hxx

@@ -19,6 +19,8 @@
 #include <OpenGl_Layer.hxx>
 #include <OpenGl_LayerFilter.hxx>
 
+#include <NCollection_Array1.hxx>
+#include <NCollection_Handle.hxx>
 #include <NCollection_Sequence.hxx>
 #include <NCollection_DataMap.hxx>
 
@@ -89,7 +91,9 @@ public:
   //! Render this element
   void Render (const Handle(OpenGl_Workspace)& theWorkspace,
                const Standard_Boolean          theToDrawImmediate,
-               const OpenGl_LayerFilter        theLayersToProcess) const;
+               const OpenGl_LayerFilter        theLayersToProcess,
+               OpenGl_FrameBuffer*             theReadDrawFbo,
+               OpenGl_FrameBuffer*             theOitAccumFbo) const;
 
   //! Returns the set of OpenGL Z-layers.
   const OpenGl_SequenceOfLayers& Layers() const { return myLayers; }
@@ -104,6 +108,132 @@ public:
   //! Returns structure modification state (for ray-tracing).
   Standard_Size ModificationStateOfRaytracable() const { return myModifStateOfRaytraceable; }
 
+protected:
+
+  //! Filter of TKOpenGl elements for processing only shading geometry and
+  //! for collecting number of skipped elements to an external counter.
+  class OpenGl_OpaqueFilter : public OpenGl_RenderFilter
+  {
+  public:
+
+    //! Constructor.
+    //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+    OpenGl_OpaqueFilter() : mySkippedCounter (0) {}
+
+    //! Sets the current active filter in workspace.
+    //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+    void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
+    //! Sets the value of the skipped elements counter.
+    void SetSkippedCounter (const Standard_Size theCounter) { mySkippedCounter = theCounter; }
+
+    //! Returns number of skipped elements.
+    Standard_Size NbSkipped() const { return mySkippedCounter; }
+
+    //! Checks whether the element should be rendered or skipped.
+    //! @param theWorkspace [in] the currently used workspace for rendering.
+    //! @param theGlElement [in] the TKOpenGl rendering queue element that should be checked before streaming to GPU.
+    Standard_EXPORT virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                                           const OpenGl_Element*           theGlElement) Standard_OVERRIDE;
+
+    DEFINE_STANDARD_RTTI_INLINE (OpenGl_OpaqueFilter, OpenGl_RenderFilter)
+
+  private:
+
+    Standard_Size mySkippedCounter;   //!< Counter of skipped elements.
+    Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
+  };
+
+  //! Filter of TKOpenGl elements for keeping only shading geometry with transparency.
+  class OpenGl_TransparentFilter : public OpenGl_RenderFilter
+  {
+  public:
+
+    //! Constructor.
+    OpenGl_TransparentFilter() {}
+
+    //! Sets the current active filter in workspace.
+    //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+    void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
+    //! Checks whether the element should be rendered or skipped.
+    //! @param theWorkspace [in] the currently used workspace for rendering.
+    //! @param theGlElement [in] the TKOpenGl rendering queue element that should be checked before streaming to GPU.
+    Standard_EXPORT virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                                           const OpenGl_Element*           theGlElement) Standard_OVERRIDE;
+
+    DEFINE_STANDARD_RTTI_INLINE (OpenGl_TransparentFilter, OpenGl_RenderFilter)
+
+  private:
+
+    Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
+  };
+
+  //! Stack of references to existing layers of predefined maximum size.
+  class OpenGl_LayerStack
+  {
+  public:
+    typedef NCollection_Array1<const OpenGl_Layer*>::iterator iterator;
+
+    //! Reallocate internal buffer of the stack.
+    void Allocate (const Standard_Integer theSize)
+    {
+      if (theSize > 0)
+      {
+        myStackSpace = new NCollection_Array1<const OpenGl_Layer*> (1, theSize);
+        myStackSpace->Init (NULL);
+        myBackPtr    = myStackSpace->begin();
+      }
+      else
+      {
+        myStackSpace.Nullify();
+        myBackPtr = iterator();
+      }
+    }
+
+    //! Clear stack.
+    void Clear()
+    {
+      if (myStackSpace)
+      {
+        myStackSpace->Init (NULL);
+        myBackPtr = myStackSpace->begin();
+      }
+    }
+
+    //! Push a new layer reference to the stack.
+    void Push (const OpenGl_Layer* theLayer) { (*myBackPtr++) = theLayer; }
+
+    //! Returns iterator to the origin of the stack.
+    iterator Origin() const { return myStackSpace.IsNull() ? iterator() : myStackSpace->begin(); }
+
+    //! Returns iterator to the back of the stack (after last item added).
+    iterator Back() const { return myBackPtr; }
+
+    //! Returns true if nothing has been pushed into the stack.
+    Standard_Boolean IsEmpty() const { return Back() == Origin(); }
+
+  private:
+
+    NCollection_Handle<NCollection_Array1<const OpenGl_Layer*> > myStackSpace;
+    iterator                                                     myBackPtr;
+  };
+
+  //! Render transparent objects using blending operator.
+  //! Additional accumulation framebuffer is used for blended order-independent
+  //! transparency algorithm. It should support floating-point color components
+  //! and share depth with main reading/drawing framebuffer.
+  //! @param theWorkspace [in] the currently used workspace for rendering.
+  //! @param theLayerIter [in/out] the current iterator of transparent layers to process.
+  //! @param theGlobalSettings [in] the set of global settings used for rendering.
+  //! @param theReadDrawFbo [in] the framebuffer for reading depth and writing final color.
+  //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
+  void renderTransparent (const Handle(OpenGl_Workspace)&   theWorkspace,
+                          OpenGl_LayerStack::iterator&      theLayerIter,
+                          const OpenGl_GlobalLayerSettings& theGlobalSettings,
+                          OpenGl_FrameBuffer*               theReadDrawFbo,
+                          OpenGl_FrameBuffer*               theOitAccumFbo) const;
+
 protected:
 
   // number of structures temporary put to default layer
@@ -117,6 +247,12 @@ protected:
 
   mutable Standard_Size   myModifStateOfRaytraceable;
 
+  //! Collection of references to layers with transparency gathered during rendering pass.
+  mutable OpenGl_LayerStack myTransparentToProcess;
+
+  Handle(OpenGl_OpaqueFilter)      myRenderOpaqueFilter; //!< rendering filter for opaque drawing pass (blended OIT).
+  Handle(OpenGl_TransparentFilter) myRenderTranspFilter; //!< rendering filter for transparency drawing pass (blended OIT).
+
 public:
 
   DEFINE_STANDARD_ALLOC

src/OpenGl/OpenGl_OitUniformState.hxx

@@ -0,0 +1,55 @@
+// Created on: 2017-01-26
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 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_OitUniformState_HeaderFile
+#define _OpenGl_OitUniformState_HeaderFile
+
+#include <OpenGl_ShaderStates.hxx>
+
+//! Defines generic state of order-independent transparency rendering properties.
+class OpenGl_OitUniformState : public OpenGl_StateInterface
+{
+public:
+
+  //! Creates new uniform state.
+  OpenGl_OitUniformState() : myToEnableWrite (false), myDepthWeight (0.5f) {}
+
+  //! Sets the uniform values.
+  //! @param theToEnableWrite [in] flag indicating whether color and coverage
+  //!  values for OIT processing should be written by shader program.
+  //! @param theDepthWeight [in] scalar factor [0-1] defining influence of depth
+  //!  component of a fragment to its final coverage coefficient.
+  void Set (const bool  theToEnableWrite,
+            const float theDepthWeight)
+  {
+    myToEnableWrite = theToEnableWrite;
+    myDepthWeight   = Max (0.f, Min (1.f, theDepthWeight));
+  }
+
+  //! Returns flag indicating whether writing of output for OIT processing
+  //! should be enabled/disabled.
+  bool ToEnableWrite() const { return myToEnableWrite; }
+
+  //! Returns factor defining influence of depth component of a fragment
+  //! to its final coverage coefficient.
+  float DepthWeight() const { return myDepthWeight; }
+
+private:
+
+  bool  myToEnableWrite; //!< writing color and coverage.
+  float myDepthWeight;   //!< factor of depth influence to coverage.
+};
+
+#endif // _OpenGl_OitUniformState_HeaderFile

src/OpenGl/OpenGl_PrimitiveArray.hxx

@@ -40,6 +40,14 @@ public:
     DRAW_MODE_NONE = -1
   };
 
+#if !defined(GL_ES_VERSION_2_0)
+  static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
+  static const GLint THE_FILLPRIM_TO   = GL_POLYGON;
+#else
+  static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
+  static const GLint THE_FILLPRIM_TO   = GL_TRIANGLE_FAN;
+#endif
+
   //! Empty constructor
   Standard_EXPORT OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver);
 

src/OpenGl/OpenGl_RenderFilter.hxx

@@ -23,6 +23,7 @@ class OpenGl_RenderFilter;
 DEFINE_STANDARD_HANDLE (OpenGl_RenderFilter, Standard_Transient)
 
 class OpenGl_Element;
+class OpenGl_Workspace;
 
 //! Base class for defining element rendering filters.
 //! This class can be used in pair with advance rendering passes, and for 
@@ -32,13 +33,14 @@ class OpenGl_RenderFilter : public Standard_Transient
 public:
 
   //! Checks whether the element can be rendered or not.
+  //! @param theWorkspace [in] the current workspace.
   //! @param theElement [in] the element to check.
   //! @return True if element can be rendered.
-  virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) = 0;
+  virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace, const OpenGl_Element* theElement) = 0;
 
 public:
 
-  DEFINE_STANDARD_RTTIEXT(OpenGl_RenderFilter,Standard_Transient)
+  DEFINE_STANDARD_RTTIEXT(OpenGl_RenderFilter, Standard_Transient)
 };
 
 #endif

src/OpenGl/OpenGl_SetOfShaderPrograms.hxx

@@ -31,7 +31,8 @@ enum OpenGl_ProgramOptions
   OpenGl_PO_ClipPlanes1 = 0x040, //!< handle 1 clipping plane
   OpenGl_PO_ClipPlanes2 = 0x080, //!< handle 2 clipping planes
   OpenGl_PO_ClipPlanesN = 0x100, //!< handle N clipping planes
-  OpenGl_PO_NB          = 0x200  //!< overall number of combinations
+  OpenGl_PO_WriteOit    = 0x200, //!< write color/coverage buffer for blended order independet transparency
+  OpenGl_PO_NB          = 0x400  //!< overall number of combinations
 };
 
 //! Alias to programs array of predefined length

src/OpenGl/OpenGl_ShaderManager.cxx

@@ -331,6 +331,12 @@ const char THE_FRAG_CLIP_PLANES_2[] =
   }
 #endif
 
+//! Output color and coverage for accumulation by OIT algorithm.
+const char THE_FRAG_write_oit_buffers[] =
+  EOL"  float aWeight     = occFragColor.a * clamp (1e+2 * pow (1.0 - gl_FragCoord.z * occOitDepthWeight, 3.0), 1e-2, 1e+2);"
+  EOL"  occFragCoverage.r = occFragColor.a * aWeight;"
+  EOL"  occFragColor      = vec4 (occFragColor.rgb * occFragColor.a * aWeight, occFragColor.a);";
+
 }
 
 // =======================================================================
@@ -1069,6 +1075,37 @@ void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)
   }
 }
 
+// =======================================================================
+// function : PushOitUniformState
+// purpose  : Pushes state of OIT uniforms to the specified program
+// =======================================================================
+void OpenGl_ShaderManager::PushOitUniformState (const Handle(OpenGl_ShaderProgram)& theProgram) const
+{
+  if (!theProgram->IsValid())
+  {
+    return;
+  }
+
+  if (myOitUniformState.Index() == theProgram->ActiveState (OpenGL_OIT_UNIFORM_STATE))
+  {
+    return;
+  }
+
+  const GLint aLocEnableWrite = theProgram->GetStateLocation (OpenGl_OCCT_OIT_ENABLE_WRITE);
+  if (aLocEnableWrite != OpenGl_ShaderProgram::INVALID_LOCATION)
+  {
+    theProgram->SetUniform (myContext, aLocEnableWrite,
+                            myOitUniformState.ToEnableWrite());
+  }
+
+  const GLint aLocDepthWeight = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_WEIGHT);
+  if (aLocDepthWeight != OpenGl_ShaderProgram::INVALID_LOCATION)
+  {
+    theProgram->SetUniform (myContext, aLocDepthWeight,
+                            myOitUniformState.DepthWeight());
+  }
+}
+
 // =======================================================================
 // function : PushState
 // purpose  : Pushes state of OCCT graphics parameters to the program
@@ -1082,6 +1119,7 @@ void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& thePro
   PushProjectionState  (aProgram);
   PushLightSourceState (aProgram);
   PushMaterialState    (aProgram);
+  PushOitUniformState  (aProgram);
 }
 
 // =======================================================================
@@ -1208,6 +1246,82 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
   return Standard_True;
 }
 
+// =======================================================================
+// function : prepareStdProgramOitCompositing
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
+{
+  Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram [theMsaa ? 1 : 0];
+  Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+  TCollection_AsciiString aSrcVert, aSrcFrag;
+
+  aSrcVert =
+    EOL"THE_SHADER_OUT vec2 TexCoord;"
+    EOL"void main()"
+    EOL"{"
+    EOL"  TexCoord    = occVertex.zw;"
+    EOL"  gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
+    EOL"}";
+
+  if (!theMsaa)
+  {
+    aSrcFrag =
+      EOL"uniform sampler2D uAccumTexture;"
+      EOL"uniform sampler2D uWeightTexture;"
+      EOL
+      EOL"THE_SHADER_IN vec2 TexCoord;"
+      EOL
+      EOL"void main()"
+      EOL"{"
+      EOL"  vec4 aAccum   = occTexture2D (uAccumTexture,  TexCoord);"
+      EOL"  float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
+      EOL"  occFragColor = vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a);"
+      EOL"}";
+
+    if (myContext->IsGlGreaterEqual (3, 2))
+    {
+      aProgramSrc->SetHeader ("#version 150");
+    }
+  }
+  else
+  {
+    aSrcFrag =
+      EOL"uniform sampler2DMS uAccumTexture;"
+      EOL"uniform sampler2DMS uWeightTexture;"
+      EOL
+      EOL"THE_SHADER_IN vec2 TexCoord;"
+      EOL
+      EOL"void main()"
+      EOL"{"
+      EOL"  ivec2 aTexel  = ivec2 (textureSize (uAccumTexture) * TexCoord);"
+      EOL"  vec4 aAccum   = texelFetch (uAccumTexture,  aTexel, gl_SampleID);"
+      EOL"  float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
+      EOL"  occFragColor = vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a);"
+      EOL"}";
+
+    if (myContext->IsGlGreaterEqual (4, 0))
+    {
+      aProgramSrc->SetHeader ("#version 400");
+    }
+  }
+
+  aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
+  aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+  TCollection_AsciiString aKey;
+  if (!Create (aProgramSrc, aKey, aProgram))
+  {
+    aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
+    return Standard_False;
+  }
+
+  myContext->BindProgram (aProgram);
+  aProgram->SetSampler (myContext, "uAccumTexture", 0);
+  aProgram->SetSampler (myContext, "uWeightTexture", 1);
+  myContext->BindProgram (NULL);
+  return Standard_True;
+}
+
 // =======================================================================
 // function : pointSpriteAlphaSrc
 // purpose  :
@@ -1249,7 +1363,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
                                                               const Standard_Integer        theBits)
 {
   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
-  TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
+  TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcFrag;
+  TCollection_AsciiString aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
   TCollection_AsciiString aSrcFragGetColor     = EOL"vec4 getColor(void) { return occColor; }";
   TCollection_AsciiString aSrcFragMainGetColor = EOL"  occFragColor = getColor();";
   if ((theBits & OpenGl_PO_Point) != 0)
@@ -1351,6 +1466,10 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
     }
   }
+  if ((theBits & OpenGl_PO_WriteOit) != 0)
+  {
+    aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
+  }
 
   TCollection_AsciiString aSrcVertEndMain;
   if ((theBits & OpenGl_PO_StippleLine) != 0)
@@ -1421,6 +1540,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
       EOL"{"
     + aSrcFragExtraMain
     + aSrcFragMainGetColor
+    + aSrcFragWriteOit
     + EOL"}";
 
 #if !defined(GL_ES_VERSION_2_0)
@@ -1572,7 +1692,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
                                                                  const Standard_Integer        theBits)
 {
   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
-  TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
+  TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut;
+  TCollection_AsciiString aSrcFragExtraMain, aSrcFragWriteOit;
   TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
   if ((theBits & OpenGl_PO_Point) != 0)
   {
@@ -1640,6 +1761,10 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
     }
   }
+  if ((theBits & OpenGl_PO_WriteOit) != 0)
+  {
+    aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
+  }
 
   const TCollection_AsciiString aLights = stdComputeLighting ((theBits & OpenGl_PO_VertColor) != 0);
   aSrcVert = TCollection_AsciiString()
@@ -1673,7 +1798,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
       EOL"{"
     + aSrcFragExtraMain
     + EOL"  occFragColor = getColor();"
-      EOL"}";
+    + aSrcFragWriteOit
+    + EOL"}";
 
 #if !defined(GL_ES_VERSION_2_0)
   if (myContext->core32 != NULL)
@@ -1702,7 +1828,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
   #define thePhongCompLight "computeLighting (normalize (Normal), normalize (View), Position, gl_FrontFacing)"
 
   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
-  TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain;
+  TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut;
+  TCollection_AsciiString aSrcFragGetVertColor, aSrcFragExtraMain, aSrcFragWriteOit;
   TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return " thePhongCompLight "; }";
   if ((theBits & OpenGl_PO_Point) != 0)
   {
@@ -1763,6 +1890,10 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
     }
   }
+  if ((theBits & OpenGl_PO_WriteOit) != 0)
+  {
+    aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
+  }
 
   aSrcVert = TCollection_AsciiString()
     + THE_FUNC_transformNormal
@@ -1799,7 +1930,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
       EOL"{"
     + aSrcFragExtraMain
     + EOL"  occFragColor = getColor();"
-      EOL"}";
+    + aSrcFragWriteOit
+    + EOL"}";
 
 #if !defined(GL_ES_VERSION_2_0)
   if (myContext->core32 != NULL)

src/OpenGl/OpenGl_ShaderManager.hxx

@@ -23,12 +23,13 @@
 #include <NCollection_DataMap.hxx>
 #include <NCollection_Sequence.hxx>
 
-#include <OpenGl_SetOfShaderPrograms.hxx>
-#include <OpenGl_ShaderStates.hxx>
 #include <OpenGl_AspectFace.hxx>
 #include <OpenGl_AspectLine.hxx>
-#include <OpenGl_AspectText.hxx>
 #include <OpenGl_AspectMarker.hxx>
+#include <OpenGl_AspectText.hxx>
+#include <OpenGl_OitUniformState.hxx>
+#include <OpenGl_SetOfShaderPrograms.hxx>
+#include <OpenGl_ShaderStates.hxx>
 #include <OpenGl_MaterialState.hxx>
 #include <OpenGl_Texture.hxx>
 
@@ -168,6 +169,19 @@ public:
          && myContext->BindProgram (myBlitProgram);
   }
 
+  //! Bind program for blended order-independent transparency buffers compositing.
+  Standard_Boolean BindOitCompositingProgram (const Standard_Boolean theIsMSAAEnabled)
+  {
+    const Standard_Integer aProgramIdx = theIsMSAAEnabled ? 1 : 0;
+    if (myOitCompositingProgram[aProgramIdx].IsNull())
+    {
+      prepareStdProgramOitCompositing (theIsMSAAEnabled);
+    }
+
+    const Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram [aProgramIdx];
+    return !aProgram.IsNull() && myContext->BindProgram (aProgram);
+  }
+
   //! Bind program for rendering stereoscopic image.
   Standard_Boolean BindStereoProgram (const Graphic3d_StereoMode theStereoMode)
   {
@@ -267,6 +281,20 @@ public:
   //! Pushes current state of material to specified program.
   void PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 
+public:
+
+  //! Set the state of OIT rendering pass.
+  //! @param theToEnableOitWrite [in] flag indicating whether the special output should be written for OIT algorithm.
+  //! @param theDepthWeight [in] the scalar factor of depth influence to the fragment's coverage.
+  void SetOitState (const bool theToEnableOitWrite, const float theDepthWeight)
+  {
+    myOitUniformState.Set (theToEnableOitWrite, theDepthWeight);
+    myOitUniformState.Update();
+  }
+
+  //! Pushes state of OIT uniforms to the specified program.
+  Standard_EXPORT void PushOitUniformState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
+
 public:
 
   //! Pushes current state of OCCT graphics parameters to specified program.
@@ -339,6 +367,12 @@ protected:
     {
       aBits |= OpenGl_PO_VertColor;
     }
+
+    if (myOitUniformState.ToEnableWrite())
+    {
+      aBits |= OpenGl_PO_WriteOit;
+    }
+
     return aBits;
   }
 
@@ -378,6 +412,9 @@ protected:
   //! Prepare standard GLSL program for FBO blit operation.
   Standard_EXPORT Standard_Boolean prepareStdProgramFboBlit();
 
+  //! Prepare standard GLSL programs for Oit compositing operation.
+  Standard_EXPORT Standard_Boolean prepareStdProgramOitCompositing (const Standard_Boolean theMsaa);
+
   //! Prepare standard GLSL program without lighting.
   Standard_EXPORT Standard_Boolean prepareStdProgramFlat (Handle(OpenGl_ShaderProgram)& theProgram,
                                                           const Standard_Integer        theBits);
@@ -452,13 +489,14 @@ protected:
 
   Handle(OpenGl_ShaderProgramFFP)    myFfpProgram;
 
-  Graphic3d_TypeOfShadingModel       myShadingModel;       //!< lighting shading model
-  OpenGl_ShaderProgramList           myProgramList;        //!< The list of shader programs
-  Handle(OpenGl_SetOfShaderPrograms) myLightPrograms;      //!< pointer to active lighting programs matrix
-  OpenGl_SetOfShaderPrograms         myFlatPrograms;       //!< programs matrix without  lighting
-  Handle(OpenGl_ShaderProgram)       myFontProgram;        //!< standard program for textured text
-  Handle(OpenGl_ShaderProgram)       myBlitProgram;        //!< standard program for FBO blit emulation
-  OpenGl_MapOfShaderPrograms         myMapOfLightPrograms; //!< map of lighting programs depending on shading model and lights configuration
+  Graphic3d_TypeOfShadingModel       myShadingModel;             //!< lighting shading model
+  OpenGl_ShaderProgramList           myProgramList;              //!< The list of shader programs
+  Handle(OpenGl_SetOfShaderPrograms) myLightPrograms;            //!< pointer to active lighting programs matrix
+  OpenGl_SetOfShaderPrograms         myFlatPrograms;             //!< programs matrix without  lighting
+  Handle(OpenGl_ShaderProgram)       myFontProgram;              //!< standard program for textured text
+  Handle(OpenGl_ShaderProgram)       myBlitProgram;              //!< standard program for FBO blit emulation
+  Handle(OpenGl_ShaderProgram)       myOitCompositingProgram[2]; //!< standard program for OIT compositing (default and msaa).
+  OpenGl_MapOfShaderPrograms         myMapOfLightPrograms;       //!< map of lighting programs depending on shading model and lights configuration
 
   Handle(OpenGl_ShaderProgram)       myStereoPrograms[Graphic3d_StereoMode_NB]; //!< standard stereo programs
 
@@ -472,6 +510,7 @@ protected:
   OpenGl_ClippingState               myClippingState;      //!< State of OCCT clipping planes
   OpenGl_LightSourceState            myLightSourceState;   //!< State of OCCT light sources
   OpenGl_MaterialState               myMaterialState;      //!< State of Front and Back materials
+  OpenGl_OitUniformState             myOitUniformState;    //!< State of OIT uniforms
 
   gp_XYZ                             myLocalOrigin;        //!< local camera transformation
   Standard_Boolean                   myHasLocalOrigin;     //!< flag indicating that local camera transformation has been set

src/OpenGl/OpenGl_ShaderProgram.cxx

@@ -70,11 +70,27 @@ Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] =
   "occBackMaterial",       // OpenGl_OCCT_BACK_MATERIAL
   "occColor",              // OpenGl_OCCT_COLOR
 
+  "occOitEnableWrite",     // OpenGl_OCCT_OIT_ENABLE_WRITE
+  "occOitDepthWeight",     // OpenGl_OCCT_OIT_DEPTH_WEIGHT
+
   "occTexTrsf2d",          // OpenGl_OCCT_TEXTURE_TRSF2D
   "occPointSize"           // OpenGl_OCCT_POINT_SIZE
-
 };
 
+namespace
+{
+  #define EOL "\n"
+  const char THE_enable_draw_buffers[] =
+    EOL"#ifdef GL_ES"
+    EOL"  #if (__VERSION__ < 300)"
+    EOL"    #extension GL_EXT_draw_buffers : enable"
+    EOL"  #endif"
+    EOL"#else"
+    EOL"  #extension GL_ARB_draw_buffers : enable"
+    EOL"#endif"
+    EOL"#define OCC_enable_draw_buffers 1";
+}
+
 // =======================================================================
 // function : OpenGl_VariableSetterSelector
 // purpose  : Creates new variable setter selector
@@ -204,11 +220,16 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
     }
 
     TCollection_AsciiString aSource = aDeclarations + anIter.Value()->Source();
+    TCollection_AsciiString aExtensions;
+    if (theCtx->MaxDrawBuffers() > 1) {
+      aExtensions += THE_enable_draw_buffers;
+    }
+
     switch (anIter.Value()->Type())
     {
       case Graphic3d_TOS_VERTEX:
       {
-        aSource = aHeader + TCollection_AsciiString ("#define VERTEX_SHADER\n") + aSource;
+        aSource = aHeader + TCollection_AsciiString ("#define VERTEX_SHADER\n") + aExtensions + aSource;
         break;
       }
       case Graphic3d_TOS_FRAGMENT:
@@ -219,9 +240,9 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
                                          "precision highp int;\n"
                                        : "precision mediump float;\n"
                                          "precision mediump int;\n");
-        aSource = aHeader + aPrefix + aSource;
+        aSource = aHeader + aPrefix + aExtensions + aSource;
       #else
-        aSource = aHeader + aSource;
+        aSource = aHeader + aExtensions + aSource;
       #endif
         break;
       }

src/OpenGl/OpenGl_ShaderProgram.hxx

@@ -65,6 +65,11 @@ enum OpenGl_StateVariable
   OpenGl_OCCT_BACK_MATERIAL,
   OpenGl_OCCT_COLOR,
 
+  // Order-independent transparency rendering state
+  OpenGl_OCCT_OIT_ENABLE_WRITE, //!< Enable bit for writing color (occFragColor) and coverage (occFragCoverage) buffers of OIT processing
+  OpenGl_OCCT_OIT_DEPTH_WEIGHT, //!< Influence of the depth component to the coverage of the accumulated fragment
+
+  // Context-dependent state
   OpenGl_OCCT_TEXTURE_TRSF2D,
   OpenGl_OCCT_POINT_SIZE,
 
@@ -124,6 +129,7 @@ enum OpenGl_UniformStateType
   OpenGl_PROJECTION_STATE,
   OpenGl_MATERIAL_STATE,
   OpenGl_SURF_DETAIL_STATE,
+  OpenGL_OIT_UNIFORM_STATE,
   OpenGl_UniformStateType_NB
 };
 

src/OpenGl/OpenGl_Texture.cxx

@@ -900,6 +900,20 @@ bool OpenGl_Texture::Init3D (const Handle(OpenGl_Context)& theCtx,
     Unbind (theCtx);
     return false;
   }
+  else if (theDataType == GL_HALF_FLOAT && !theCtx->arbTexHalfFloat)
+  {
+    TCollection_ExtendedString aMsg ("Error: half-precision floating-point textures are not supported by hardware.");
+
+    theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+                         GL_DEBUG_TYPE_ERROR,
+                         0,
+                         GL_DEBUG_SEVERITY_HIGH,
+                         aMsg);
+
+    Release (theCtx.operator->());
+    Unbind (theCtx);
+    return false;
+  }
 
   const GLint anIntFormat = theTextFormat;
 

src/OpenGl/OpenGl_View.cxx

@@ -61,11 +61,17 @@ OpenGl_View::OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
   myToShowGradTrihedron  (false),
   myStateCounter         (theCounter),
   myLastLightSourceState (0, 0),
+#if !defined(GL_ES_VERSION_2_0)
   myFboColorFormat       (GL_RGBA8),
+#else
+  myFboColorFormat       (GL_RGBA),
+#endif
   myFboDepthFormat       (GL_DEPTH24_STENCIL8),
   myToFlipOutput         (Standard_False),
   myFrameCounter         (0),
   myHasFboBlit           (Standard_True),
+  myToDisableOIT         (Standard_False),
+  myToDisableOITMSAA     (Standard_False),
   myToDisableMSAA        (Standard_False),
   myTransientDrawToFront (Standard_True),
   myBackBufferRestored   (Standard_False),
@@ -90,17 +96,21 @@ OpenGl_View::OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
   aLight.Color.b()   = 1.;
   myNoShadingLight.Append (aLight);
 
-  myCurrLightSourceState  = myStateCounter->Increment();
-  myMainSceneFbos[0]      = new OpenGl_FrameBuffer();
-  myMainSceneFbos[1]      = new OpenGl_FrameBuffer();
-  myImmediateSceneFbos[0] = new OpenGl_FrameBuffer();
-  myImmediateSceneFbos[1] = new OpenGl_FrameBuffer();
-  myOpenGlFBO             = new OpenGl_FrameBuffer();
-  myOpenGlFBO2            = new OpenGl_FrameBuffer();
-  myRaytraceFBO1[0]       = new OpenGl_FrameBuffer();
-  myRaytraceFBO1[1]       = new OpenGl_FrameBuffer();
-  myRaytraceFBO2[0]       = new OpenGl_FrameBuffer();
-  myRaytraceFBO2[1]       = new OpenGl_FrameBuffer();
+  myCurrLightSourceState     = myStateCounter->Increment();
+  myMainSceneFbos[0]         = new OpenGl_FrameBuffer();
+  myMainSceneFbos[1]         = new OpenGl_FrameBuffer();
+  myMainSceneFbosOit[0]      = new OpenGl_FrameBuffer();
+  myMainSceneFbosOit[1]      = new OpenGl_FrameBuffer();
+  myImmediateSceneFbos[0]    = new OpenGl_FrameBuffer();
+  myImmediateSceneFbos[1]    = new OpenGl_FrameBuffer();
+  myImmediateSceneFbosOit[0] = new OpenGl_FrameBuffer();
+  myImmediateSceneFbosOit[1] = new OpenGl_FrameBuffer();
+  myOpenGlFBO                = new OpenGl_FrameBuffer();
+  myOpenGlFBO2               = new OpenGl_FrameBuffer();
+  myRaytraceFBO1[0]          = new OpenGl_FrameBuffer();
+  myRaytraceFBO1[1]          = new OpenGl_FrameBuffer();
+  myRaytraceFBO2[0]          = new OpenGl_FrameBuffer();
+  myRaytraceFBO2[1]          = new OpenGl_FrameBuffer();
 }
 
 // =======================================================================
@@ -142,14 +152,18 @@ void OpenGl_View::ReleaseGlResources (const Handle(OpenGl_Context)& theCtx)
     myBgTextureArray->Release (theCtx.operator->());
   }
 
-  myMainSceneFbos[0]     ->Release (theCtx.operator->());
-  myMainSceneFbos[1]     ->Release (theCtx.operator->());
-  myImmediateSceneFbos[0]->Release (theCtx.operator->());
-  myImmediateSceneFbos[1]->Release (theCtx.operator->());
-  myOpenGlFBO            ->Release (theCtx.operator->());
-  myOpenGlFBO2           ->Release (theCtx.operator->());
-  myFullScreenQuad        .Release (theCtx.operator->());
-  myFullScreenQuadFlip    .Release (theCtx.operator->());
+  myMainSceneFbos[0]        ->Release (theCtx.operator->());
+  myMainSceneFbos[1]        ->Release (theCtx.operator->());
+  myMainSceneFbosOit[0]     ->Release (theCtx.operator->());
+  myMainSceneFbosOit[1]     ->Release (theCtx.operator->());
+  myImmediateSceneFbos[0]   ->Release (theCtx.operator->());
+  myImmediateSceneFbos[1]   ->Release (theCtx.operator->());
+  myImmediateSceneFbosOit[0]->Release (theCtx.operator->());
+  myImmediateSceneFbosOit[1]->Release (theCtx.operator->());
+  myOpenGlFBO               ->Release (theCtx.operator->());
+  myOpenGlFBO2              ->Release (theCtx.operator->());
+  myFullScreenQuad           .Release (theCtx.operator->());
+  myFullScreenQuadFlip       .Release (theCtx.operator->());
 
   releaseRaytraceResources (theCtx);
 }

src/OpenGl/OpenGl_View.hxx

@@ -342,6 +342,22 @@ public:
     return myZLayers.NbImmediateStructures() != 0;
   }
 
+  //! Set filter for restricting rendering of particular elements.
+  //! Filter can be applied for rendering passes used by recursive
+  //! rendering algorithms for rendering elements of groups.
+  //! @param theFilter [in] the filter instance.
+  inline void SetRenderFilter(const Handle(OpenGl_RenderFilter)& theFilter)
+  {
+    myWorkspace->SetRenderFilter(theFilter);
+  }
+
+  //! Get rendering filter.
+  //! @return filter instance.
+  inline const Handle(OpenGl_RenderFilter)& GetRenderFilter() const
+  {
+    return myWorkspace->GetRenderFilter();
+  }
+
 protected: //! @name Internal methods for managing GL resources
 
   //! Initializes OpenGl resource for environment texture.
@@ -351,7 +367,8 @@ protected: //! @name low-level redrawing sub-routines
 
   //! Redraws view for the given monographic camera projection, or left/right eye.
   Standard_EXPORT virtual void redraw (const Graphic3d_Camera::Projection theProjection,
-                                       OpenGl_FrameBuffer*                theReadDrawFbo);
+                                       OpenGl_FrameBuffer*                theReadDrawFbo,
+                                       OpenGl_FrameBuffer*                theOitAccumFbo);
 
   //! Redraws view for the given monographic camera projection, or left/right eye.
   //!
@@ -368,6 +385,7 @@ protected: //! @name low-level redrawing sub-routines
   Standard_EXPORT virtual bool redrawImmediate (const Graphic3d_Camera::Projection theProjection,
                                                 OpenGl_FrameBuffer* theReadFbo,
                                                 OpenGl_FrameBuffer* theDrawFbo,
+                                                OpenGl_FrameBuffer* theOitAccumFbo,
                                                 const Standard_Boolean theIsPartialUpdate = Standard_False);
 
   //! Blit image from/to specified buffers.
@@ -383,17 +401,21 @@ protected: //! @name Rendering of GL graphics (with prepared drawing buffer).
   //! Renders the graphical contents of the view into the preprepared window or framebuffer.
   //! @param theProjection [in] the projection that should be used for rendering.
   //! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
+  //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
   //! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
   Standard_EXPORT virtual void render (Graphic3d_Camera::Projection theProjection,
                                        OpenGl_FrameBuffer*          theReadDrawFbo,
+                                       OpenGl_FrameBuffer*          theOitAccumFbo,
                                        const Standard_Boolean       theToDrawImmediate);
 
   //! Renders the graphical scene.
   //! @param theProjection [in] the projection that is used for rendering.
   //! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
+  //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
   //! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
   Standard_EXPORT virtual void renderScene (Graphic3d_Camera::Projection theProjection,
                                             OpenGl_FrameBuffer*    theReadDrawFbo,
+                                            OpenGl_FrameBuffer*    theOitAccumFbo,
                                             const Standard_Boolean theToDrawImmediate);
 
   //! Draw background (gradient / image)
@@ -402,9 +424,11 @@ protected: //! @name Rendering of GL graphics (with prepared drawing buffer).
   //! Render set of structures presented in the view.
   //! @param theProjection [in] the projection that is used for rendering.
   //! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
+  //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
   //! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
   Standard_EXPORT virtual void renderStructs (Graphic3d_Camera::Projection theProjection,
                                               OpenGl_FrameBuffer*    theReadDrawFbo,
+                                              OpenGl_FrameBuffer*    theOitAccumFbo,
                                               const Standard_Boolean theToDrawImmediate);
 
   //! Renders trihedron.
@@ -444,6 +468,15 @@ private:
   //! Blend together views pair into stereo image.
   void drawStereoPair (OpenGl_FrameBuffer* theDrawFbo);
 
+  //! Check and update OIT compatibility with current OpenGL context's state.
+  bool checkOitCompatibility (const Handle(OpenGl_Context)& theGlContext,
+                              const Standard_Boolean theMSAA);
+
+  //! Chooses compatible internal color format for OIT frame buffer.
+  bool chooseOitColorConfiguration (const Handle(OpenGl_Context)& theGlContext,
+                                    const Standard_Integer theConfigIndex,
+                                    OpenGl_ColorFormats& theFormats);
+
 protected:
 
   OpenGl_GraphicDriver*    myDriver;
@@ -497,13 +530,18 @@ protected: //! @name Rendering properties
   //! of the view (without presentation of immediate layers).
   GLint                      myFboColorFormat;        //!< sized format for color attachments
   GLint                      myFboDepthFormat;        //!< sized format for depth-stencil attachments
+  OpenGl_ColorFormats        myFboOitColorConfig;     //!< selected color format configuration for OIT color attachments
   Handle(OpenGl_FrameBuffer) myMainSceneFbos[2];
-  Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2]; //!< Additional buffers for immediate layer in stereo mode.
+  Handle(OpenGl_FrameBuffer) myMainSceneFbosOit[2];      //!< Additional buffers for transparent draw of main layer.
+  Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2];    //!< Additional buffers for immediate layer in stereo mode.
+  Handle(OpenGl_FrameBuffer) myImmediateSceneFbosOit[2]; //!< Additional buffers for transparency draw of immediate layer.
   OpenGl_VertexBuffer        myFullScreenQuad;        //!< Vertices for full-screen quad rendering.
   OpenGl_VertexBuffer        myFullScreenQuadFlip;
   Standard_Boolean           myToFlipOutput;          //!< Flag to draw result image upside-down
   unsigned int               myFrameCounter;          //!< redraw counter, for debugging
   Standard_Boolean           myHasFboBlit;            //!< disable FBOs on failure
+  Standard_Boolean           myToDisableOIT;          //!< disable OIT on failure
+  Standard_Boolean           myToDisableOITMSAA;      //!< disable OIT with MSAA on failure
   Standard_Boolean           myToDisableMSAA;         //!< disable MSAA after failure
   Standard_Boolean           myTransientDrawToFront; //!< optimization flag for immediate mode (to render directly to the front buffer)
   Standard_Boolean           myBackBufferRestored;
@@ -1035,6 +1073,7 @@ public:
 
   friend class OpenGl_GraphicDriver;
   friend class OpenGl_Workspace;
+  friend class OpenGl_LayerList;
 };
 
 #endif // _OpenGl_View_Header

src/OpenGl/OpenGl_View_Redraw.cxx

@@ -163,6 +163,12 @@ void OpenGl_View::Redraw()
     aNbSamples = OpenGl_Context::GetPowerOfTwo (aNbSamples, aCtx->MaxMsaaSamples());
   }
 
+  bool toUseOit = myRenderParams.IsOitEnabled
+    && checkOitCompatibility (aCtx, aNbSamples > 0);
+
+  bool toInitImmediateFbo = myTransientDrawToFront
+    && (!aCtx->caps->useSystemBuffer || (toUseOit && HasImmediateStructures()));
+
   if ( aFrameBuffer == NULL
    && !aCtx->DefaultFrameBuffer().IsNull()
    &&  aCtx->DefaultFrameBuffer()->IsValid())
@@ -173,7 +179,8 @@ void OpenGl_View::Redraw()
   if (myHasFboBlit
    && (myTransientDrawToFront
     || aProjectType == Graphic3d_Camera::Projection_Stereo
-    || aNbSamples != 0))
+    || aNbSamples != 0
+    || toUseOit))
   {
     if (myMainSceneFbos[0]->GetVPSizeX() != aSizeX
      || myMainSceneFbos[0]->GetVPSizeY() != aSizeY
@@ -193,12 +200,10 @@ void OpenGl_View::Redraw()
       {
         myMainSceneFbos[0]->Init (aCtx, aSizeX, aSizeY, myFboColorFormat, myFboDepthFormat, aNbSamples);
       }
-      if (myTransientDrawToFront
-       && !aCtx->caps->useSystemBuffer
-       && myMainSceneFbos[0]->IsValid())
-      {
-        myImmediateSceneFbos[0]->InitLazy (aCtx, *myMainSceneFbos[0]);
-      }
+    }
+    if (myMainSceneFbos[0]->IsValid() && (toInitImmediateFbo || myImmediateSceneFbos[0]->IsValid()))
+    {
+      myImmediateSceneFbos[0]->InitLazy (aCtx, *myMainSceneFbos[0]);
     }
   }
   else
@@ -238,6 +243,93 @@ void OpenGl_View::Redraw()
     }
   }
 
+  // create color and coverage accumulation buffers required for OIT algorithm
+  if (toUseOit)
+  {
+    Standard_Integer anFboIt = 0;
+    for (; anFboIt < 2; ++anFboIt)
+    {
+      if (myMainSceneFbos[anFboIt]->IsValid()
+       && (myMainSceneFbosOit[anFboIt]->GetVPSizeX() != aSizeX
+        || myMainSceneFbosOit[anFboIt]->GetVPSizeY() != aSizeY
+        || myMainSceneFbosOit[anFboIt]->NbSamples() != aNbSamples))
+      {
+        Standard_Integer aColorConfig = 0;
+        for (;;) // seemly responding to driver limitation (GL_FRAMEBUFFER_UNSUPPORTED)
+        {
+          if (myFboOitColorConfig.IsEmpty())
+          {
+            if (!chooseOitColorConfiguration (aCtx, aColorConfig++, myFboOitColorConfig))
+            {
+              break;
+            }
+          }
+          if (myMainSceneFbosOit[anFboIt]->Init (aCtx, aSizeX, aSizeY, myFboOitColorConfig, myMainSceneFbos[anFboIt]->DepthStencilTexture(), aNbSamples))
+          {
+            break;
+          }
+          myFboOitColorConfig.Clear();
+        }
+        if (!myMainSceneFbosOit[anFboIt]->IsValid())
+        {
+          break;
+        }
+      }
+      else if (!myMainSceneFbosOit[anFboIt]->IsValid())
+      {
+        myMainSceneFbosOit[anFboIt]->Release (aCtx.operator->());
+        myMainSceneFbosOit[anFboIt]->ChangeViewport (0, 0);
+      }
+
+      if (myImmediateSceneFbos[anFboIt]->IsValid()
+       && (myImmediateSceneFbosOit[anFboIt]->GetVPSizeX() != aSizeX
+        || myImmediateSceneFbosOit[anFboIt]->GetVPSizeY() != aSizeY
+        || myImmediateSceneFbosOit[anFboIt]->NbSamples() != aNbSamples))
+      {
+        if (!myImmediateSceneFbosOit[anFboIt]->Init (aCtx, aSizeX, aSizeY, myFboOitColorConfig, myImmediateSceneFbos[anFboIt]->DepthStencilTexture(), aNbSamples))
+        {
+          break;
+        }
+      }
+      else if (!myImmediateSceneFbosOit[anFboIt]->IsValid())
+      {
+        myImmediateSceneFbosOit[anFboIt]->Release (aCtx.operator->());
+        myImmediateSceneFbosOit[anFboIt]->ChangeViewport (0, 0);
+      }
+    }
+    if (!anFboIt) // only the first OIT framebuffer is mandatory
+    {
+      TCollection_ExtendedString aMsg = 
+        "Initialization of float texture framebuffer for use with\n"
+        "  blended order-independent transparency rendering algorithm has failed.\n"
+        "  Blended order-independent transparency will not be available.\n";
+
+      aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+                          GL_DEBUG_TYPE_ERROR,
+                          0,
+                          GL_DEBUG_SEVERITY_HIGH,
+                          aMsg);
+
+      if (aNbSamples > 0)
+        myToDisableOITMSAA = Standard_True;
+      else
+        myToDisableOIT     = Standard_True;
+
+      toUseOit = false;
+    }
+  }
+  if (!toUseOit && myMainSceneFbosOit[0]->IsValid())
+  {
+    myMainSceneFbosOit     [0]->Release (aCtx.operator->());
+    myMainSceneFbosOit     [1]->Release (aCtx.operator->());
+    myImmediateSceneFbosOit[0]->Release (aCtx.operator->());
+    myImmediateSceneFbosOit[1]->Release (aCtx.operator->());
+    myMainSceneFbosOit     [0]->ChangeViewport (0, 0);
+    myMainSceneFbosOit     [1]->ChangeViewport (0, 0);
+    myImmediateSceneFbosOit[0]->ChangeViewport (0, 0);
+    myImmediateSceneFbosOit[1]->ChangeViewport (0, 0);
+  }
+
   if (aProjectType == Graphic3d_Camera::Projection_Stereo)
   {
     OpenGl_FrameBuffer* aMainFbos[2] =
@@ -245,34 +337,51 @@ void OpenGl_View::Redraw()
       myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : NULL,
       myMainSceneFbos[1]->IsValid() ? myMainSceneFbos[1].operator->() : NULL
     };
+    OpenGl_FrameBuffer* aMainFbosOit[2] =
+    {
+      myMainSceneFbosOit[0]->IsValid() ? myMainSceneFbosOit[0].operator->() : NULL,
+      myMainSceneFbosOit[1]->IsValid() ? myMainSceneFbosOit[1].operator->() :
+        myMainSceneFbosOit[0]->IsValid() ? myMainSceneFbosOit[0].operator->() : NULL
+    };
+
     OpenGl_FrameBuffer* anImmFbos[2] =
     {
       myImmediateSceneFbos[0]->IsValid() ? myImmediateSceneFbos[0].operator->() : NULL,
       myImmediateSceneFbos[1]->IsValid() ? myImmediateSceneFbos[1].operator->() : NULL
     };
+    OpenGl_FrameBuffer* anImmFbosOit[2] =
+    {
+      myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL,
+      myImmediateSceneFbosOit[1]->IsValid() ? myImmediateSceneFbosOit[1].operator->() :
+        myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL
+    };
 
     if (!myTransientDrawToFront)
     {
-      anImmFbos[0] = aMainFbos[0];
-      anImmFbos[1] = aMainFbos[1];
+      anImmFbos   [0] = aMainFbos   [0];
+      anImmFbos   [1] = aMainFbos   [1];
+      anImmFbosOit[0] = aMainFbosOit[0];
+      anImmFbosOit[1] = aMainFbosOit[1];
     }
     else if (aStereoMode == Graphic3d_StereoMode_SoftPageFlip
           || aStereoMode == Graphic3d_StereoMode_QuadBuffer)
     {
-      anImmFbos[0] = NULL;
-      anImmFbos[1] = NULL;
+      anImmFbos   [0] = NULL;
+      anImmFbos   [1] = NULL;
+      anImmFbosOit[0] = NULL;
+      anImmFbosOit[1] = NULL;
     }
 
   #if !defined(GL_ES_VERSION_2_0)
     aCtx->SetReadDrawBuffer (aStereoMode == Graphic3d_StereoMode_QuadBuffer ? GL_BACK_LEFT : GL_BACK);
   #endif
-    redraw (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0]);
+    redraw (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0], aMainFbosOit[0]);
     myBackBufferRestored = Standard_True;
     myIsImmediateDrawn   = Standard_False;
   #if !defined(GL_ES_VERSION_2_0)
     aCtx->SetReadDrawBuffer (aStereoMode == Graphic3d_StereoMode_QuadBuffer ? GL_BACK_LEFT : GL_BACK);
   #endif
-    if (!redrawImmediate (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0], anImmFbos[0]))
+    if (!redrawImmediate (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0], anImmFbos[0], anImmFbosOit[0]))
     {
       toSwap = false;
     }
@@ -284,10 +393,10 @@ void OpenGl_View::Redraw()
   #if !defined(GL_ES_VERSION_2_0)
     aCtx->SetReadDrawBuffer (aStereoMode == Graphic3d_StereoMode_QuadBuffer ? GL_BACK_RIGHT : GL_BACK);
   #endif
-    redraw (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1]);
+    redraw (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1], aMainFbosOit[1]);
     myBackBufferRestored = Standard_True;
     myIsImmediateDrawn   = Standard_False;
-    if (!redrawImmediate (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1], anImmFbos[1]))
+    if (!redrawImmediate (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1], anImmFbos[1], anImmFbosOit[1]))
     {
       toSwap = false;
     }
@@ -299,15 +408,19 @@ void OpenGl_View::Redraw()
   }
   else
   {
-    OpenGl_FrameBuffer* aMainFbo = myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : aFrameBuffer;
-    OpenGl_FrameBuffer* anImmFbo = aFrameBuffer;
-    if (!aCtx->caps->useSystemBuffer && myImmediateSceneFbos[0]->IsValid())
-    {
-      anImmFbo = myImmediateSceneFbos[0].operator->();
-    }
+    OpenGl_FrameBuffer* aMainFbo    = myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : aFrameBuffer;
+    OpenGl_FrameBuffer* aMainFboOit = myMainSceneFbosOit[0]->IsValid() ? myMainSceneFbosOit[0].operator->() : NULL;
+    OpenGl_FrameBuffer* anImmFbo    = aFrameBuffer;
+    OpenGl_FrameBuffer* anImmFboOit = NULL;
     if (!myTransientDrawToFront)
     {
-      anImmFbo = aMainFbo;
+      anImmFbo    = aMainFbo;
+      anImmFboOit = aMainFboOit;
+    }
+    else if (myImmediateSceneFbos[0]->IsValid())
+    {
+      anImmFbo    = myImmediateSceneFbos[0].operator->();
+      anImmFboOit = myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL;
     }
 
   #if !defined(GL_ES_VERSION_2_0)
@@ -316,10 +429,10 @@ void OpenGl_View::Redraw()
       aCtx->SetReadDrawBuffer (GL_BACK);
     }
   #endif
-    redraw (aProjectType, aMainFbo);
+    redraw (aProjectType, aMainFbo, aMainFboOit);
     myBackBufferRestored = Standard_True;
     myIsImmediateDrawn   = Standard_False;
-    if (!redrawImmediate (aProjectType, aMainFbo, anImmFbo))
+    if (!redrawImmediate (aProjectType, aMainFbo, anImmFbo, anImmFboOit))
     {
       toSwap = false;
     }
@@ -422,11 +535,19 @@ void OpenGl_View::RedrawImmediate()
       myImmediateSceneFbos[0]->IsValid() ? myImmediateSceneFbos[0].operator->() : NULL,
       myImmediateSceneFbos[1]->IsValid() ? myImmediateSceneFbos[1].operator->() : NULL
     };
+    OpenGl_FrameBuffer* anImmFbosOit[2] =
+    {
+      myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL,
+      myImmediateSceneFbosOit[1]->IsValid() ? myImmediateSceneFbosOit[1].operator->() :
+        myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL
+    };
     if (aStereoMode == Graphic3d_StereoMode_SoftPageFlip
      || aStereoMode == Graphic3d_StereoMode_QuadBuffer)
     {
-      anImmFbos[0] = NULL;
-      anImmFbos[1] = NULL;
+      anImmFbos[0]    = NULL;
+      anImmFbos[1]    = NULL;
+      anImmFbosOit[0] = NULL;
+      anImmFbosOit[1] = NULL;
     }
 
     if (aCtx->arbFBO != NULL)
@@ -442,6 +563,7 @@ void OpenGl_View::RedrawImmediate()
     toSwap = redrawImmediate (Graphic3d_Camera::Projection_MonoLeftEye,
                               aMainFbos[0],
                               anImmFbos[0],
+                              anImmFbosOit[0],
                               Standard_True) || toSwap;
     if (aStereoMode == Graphic3d_StereoMode_SoftPageFlip
     &&  toSwap
@@ -463,6 +585,7 @@ void OpenGl_View::RedrawImmediate()
     toSwap = redrawImmediate (Graphic3d_Camera::Projection_MonoRightEye,
                               aMainFbos[1],
                               anImmFbos[1],
+                              anImmFbosOit[1],
                               Standard_True) || toSwap;
     if (anImmFbos[0] != NULL)
     {
@@ -473,9 +596,11 @@ void OpenGl_View::RedrawImmediate()
   {
     OpenGl_FrameBuffer* aMainFbo = myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : NULL;
     OpenGl_FrameBuffer* anImmFbo = aFrameBuffer;
-    if (!aCtx->caps->useSystemBuffer && myImmediateSceneFbos[0]->IsValid())
+    OpenGl_FrameBuffer* anImmFboOit = NULL;
+    if (myImmediateSceneFbos[0]->IsValid())
     {
-      anImmFbo = myImmediateSceneFbos[0].operator->();
+      anImmFbo    = myImmediateSceneFbos[0].operator->();
+      anImmFboOit = myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL;
     }
   #if !defined(GL_ES_VERSION_2_0)
     if (aMainFbo == NULL)
@@ -486,6 +611,7 @@ void OpenGl_View::RedrawImmediate()
     toSwap = redrawImmediate (aProjectType,
                               aMainFbo,
                               anImmFbo,
+                              anImmFboOit,
                               Standard_True) || toSwap;
     if (anImmFbo != NULL
      && anImmFbo != aFrameBuffer)
@@ -517,7 +643,9 @@ void OpenGl_View::RedrawImmediate()
 // function : redraw
 // purpose  :
 // =======================================================================
-void OpenGl_View::redraw (const Graphic3d_Camera::Projection theProjection, OpenGl_FrameBuffer* theReadDrawFbo)
+void OpenGl_View::redraw (const Graphic3d_Camera::Projection theProjection,
+                          OpenGl_FrameBuffer* theReadDrawFbo,
+                          OpenGl_FrameBuffer* theOitAccumFbo)
 {
   Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
   if (theReadDrawFbo != NULL)
@@ -552,7 +680,7 @@ void OpenGl_View::redraw (const Graphic3d_Camera::Projection theProjection, Open
 
   glClear (toClear);
 
-  render (theProjection, theReadDrawFbo, Standard_False);
+  render (theProjection, theReadDrawFbo, theOitAccumFbo, Standard_False);
 }
 
 // =======================================================================
@@ -562,6 +690,7 @@ void OpenGl_View::redraw (const Graphic3d_Camera::Projection theProjection, Open
 bool OpenGl_View::redrawImmediate (const Graphic3d_Camera::Projection theProjection,
                                    OpenGl_FrameBuffer*    theReadFbo,
                                    OpenGl_FrameBuffer*    theDrawFbo,
+                                   OpenGl_FrameBuffer*    theOitAccumFbo,
                                    const Standard_Boolean theIsPartialUpdate)
 {
   Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
@@ -617,7 +746,7 @@ bool OpenGl_View::redrawImmediate (const Graphic3d_Camera::Projection theProject
   glClearDepthf (1.0f);
 #endif
 
-  render (theProjection, theDrawFbo, Standard_True);
+  render (theProjection, theDrawFbo, theOitAccumFbo, Standard_True);
 
   return !toCopyBackToFront;
 }
@@ -628,6 +757,7 @@ bool OpenGl_View::redrawImmediate (const Graphic3d_Camera::Projection theProject
 //=======================================================================
 void OpenGl_View::render (Graphic3d_Camera::Projection theProjection,
                           OpenGl_FrameBuffer*          theOutputFBO,
+                          OpenGl_FrameBuffer*          theOitAccumFbo,
                           const Standard_Boolean       theToDrawImmediate)
 {
   // ==================================
@@ -752,7 +882,7 @@ void OpenGl_View::render (Graphic3d_Camera::Projection theProjection,
 
   myWorkspace->SetEnvironmentTexture (myTextureEnv);
 
-  renderScene (theProjection, theOutputFBO, theToDrawImmediate);
+  renderScene (theProjection, theOutputFBO, theOitAccumFbo, theToDrawImmediate);
 
   myWorkspace->SetEnvironmentTexture (Handle(OpenGl_Texture)());
 
@@ -812,6 +942,7 @@ void OpenGl_View::InvalidateBVHData (const Graphic3d_ZLayerId theLayerId)
 //=======================================================================
 void OpenGl_View::renderStructs (Graphic3d_Camera::Projection theProjection,
                                  OpenGl_FrameBuffer*          theReadDrawFbo,
+                                 OpenGl_FrameBuffer*          theOitAccumFbo,
                                  const Standard_Boolean       theToDrawImmediate)
 {
   if ( myZLayers.NbStructures() <= 0 )
@@ -848,7 +979,7 @@ void OpenGl_View::renderStructs (Graphic3d_Camera::Projection theProjection,
       if (aCtx->arbFBOBlit != NULL)
       {
         // Render bottom OSD layer
-        myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Bottom);
+        myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Bottom, theReadDrawFbo, theOitAccumFbo);
 
         myWorkspace->SetRenderFilter (myRaytraceFilter);
         {
@@ -862,7 +993,7 @@ void OpenGl_View::renderStructs (Graphic3d_Camera::Projection theProjection,
           }
 
           // Render non-polygonal elements in default layer
-          myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Default);
+          myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Default, theReadDrawFbo, theOitAccumFbo);
         }
         myWorkspace->SetRenderFilter (myRaytraceFilter->PrevRenderFilter());
       }
@@ -884,7 +1015,7 @@ void OpenGl_View::renderStructs (Graphic3d_Camera::Projection theProjection,
       raytrace (aSizeX, aSizeY, theProjection, theReadDrawFbo, aCtx);
 
       // Render upper (top and topmost) OpenGL layers
-      myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Upper);
+      myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Upper, theReadDrawFbo, theOitAccumFbo);
     }
   }
 
@@ -892,7 +1023,7 @@ void OpenGl_View::renderStructs (Graphic3d_Camera::Projection theProjection,
   // mode or in case of ray-tracing failure
   if (toRenderGL)
   {
-    myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_All);
+    myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_All, theReadDrawFbo, theOitAccumFbo);
 
     // Set flag that scene was redrawn by standard pipeline
     myWasRedrawnGL = Standard_True;
@@ -926,6 +1057,7 @@ void OpenGl_View::Invalidate()
 //=======================================================================
 void OpenGl_View::renderScene (Graphic3d_Camera::Projection theProjection,
                                OpenGl_FrameBuffer*          theReadDrawFbo,
+                               OpenGl_FrameBuffer*          theOitAccumFbo,
                                const Standard_Boolean       theToDrawImmediate)
 {
   const Handle(OpenGl_Context)& aContext = myWorkspace->GetGlContext();
@@ -942,7 +1074,7 @@ void OpenGl_View::renderScene (Graphic3d_Camera::Projection theProjection,
   myWorkspace->NamedStatus &= ~(OPENGL_NS_2NDPASSNEED | OPENGL_NS_2NDPASSDO);
 
   // First pass
-  renderStructs (theProjection, theReadDrawFbo, theToDrawImmediate);
+  renderStructs (theProjection, theReadDrawFbo, theOitAccumFbo, theToDrawImmediate);
   myWorkspace->DisableTexture();
 
   // Second pass
@@ -972,7 +1104,7 @@ void OpenGl_View::renderScene (Graphic3d_Camera::Projection theProjection,
     glEnable (GL_DEPTH_TEST);
 
     // Render the view
-    renderStructs (theProjection, theReadDrawFbo, theToDrawImmediate);
+    renderStructs (theProjection, theReadDrawFbo, theOitAccumFbo, theToDrawImmediate);
     myWorkspace->DisableTexture();
 
     // Restore properties back
@@ -1477,3 +1609,74 @@ void OpenGl_View::copyBackToFront()
 #endif
   myIsImmediateDrawn = Standard_False;
 }
+
+// =======================================================================
+// function : checkOitCompatibility
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_View::checkOitCompatibility (const Handle(OpenGl_Context)& theGlContext,
+                                                     const Standard_Boolean theMSAA)
+{
+  // determine if OIT is supported by current OpenGl context
+  Standard_Boolean& aToDisableOIT = theMSAA ? myToDisableMSAA : myToDisableOIT;
+
+  if (!aToDisableOIT && theMSAA)
+  {
+    if (!theGlContext->arbSampleShading)
+    {
+      TCollection_ExtendedString aMsg = TCollection_ExtendedString()
+                                      + "Current version of GLSL does not support built-in sample variables.\n"
+                                      + "  Blended order-independent transparency will not be available.\n";
+      theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+                                 GL_DEBUG_TYPE_ERROR,
+                                 0,
+                                 GL_DEBUG_SEVERITY_HIGH,
+                                 aMsg);
+
+      aToDisableOIT = Standard_True;
+    }
+  }
+  else if (!aToDisableOIT)
+  {
+    if (theGlContext->MaxDrawBuffers() < 2)
+    {
+      TCollection_ExtendedString aMsg = TCollection_ExtendedString()
+                                      + "OpenGL context does not support multiple rendering targets.\n"
+                                      + "  Blended order-independent transparency will not be available.\n";
+      theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+                                 GL_DEBUG_TYPE_ERROR,
+                                 0,
+                                 GL_DEBUG_SEVERITY_HIGH,
+                                 aMsg);
+      aToDisableOIT = Standard_True;
+    }
+  }
+
+  return !aToDisableOIT;
+}
+
+// =======================================================================
+// function : chooseOitColorConfiguration
+// purpose  :
+// =======================================================================
+bool OpenGl_View::chooseOitColorConfiguration (const Handle(OpenGl_Context)& theGlContext,
+                                               const Standard_Integer theConfigIndex,
+                                               OpenGl_ColorFormats& theFormats)
+{
+  theFormats.Clear();
+
+  switch (theConfigIndex)
+  {
+    case 0: // choose best applicable color format combination
+      theFormats.Append (theGlContext->arbTexHalfFloat ? GL_RGBA16F : GL_RGBA32F);
+      theFormats.Append (theGlContext->arbTexHalfFloat ? GL_R16F    : GL_R32F);
+      return true;
+
+    case 1: // choose non-optimal applicable color format combination
+      theFormats.Append (theGlContext->arbTexHalfFloat ? GL_RGBA16F : GL_RGBA32F);
+      theFormats.Append (theGlContext->arbTexHalfFloat ? GL_RGBA16F : GL_RGBA32F);
+      return true;
+  }
+
+  return false; // color combination does not exist
+}

src/OpenGl/OpenGl_Workspace.cxx

@@ -715,7 +715,7 @@ const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
   }
   else
   {
-    myGlContext->SetShadingMaterial (myAspectFaceSet, myHighlightStyle, myUseDepthWrite, NamedStatus);
+    myGlContext->SetShadingMaterial (myAspectFaceSet, myHighlightStyle, NamedStatus);
   }
 
   if (myAspectFaceSet->Aspect()->ToMapTexture())
@@ -1107,15 +1107,16 @@ Standard_Boolean OpenGl_Workspace::BufferDump (const Handle(OpenGl_FrameBuffer)&
 }
 
 // =======================================================================
-// function : CanRender
+// function : ShouldRender
 // purpose  :
 // =======================================================================
-Standard_Boolean OpenGl_RaytraceFilter::CanRender (const OpenGl_Element* theElement)
+Standard_Boolean OpenGl_RaytraceFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                                      const OpenGl_Element* theElement)
 {
   Standard_Boolean aPrevFilterResult = Standard_True;
   if (!myPrevRenderFilter.IsNull())
   {
-    aPrevFilterResult = myPrevRenderFilter->CanRender (theElement);
+    aPrevFilterResult = myPrevRenderFilter->ShouldRender (theWorkspace, theElement);
   }
   return aPrevFilterResult &&
     !OpenGl_Raytrace::IsRaytracedElement (theElement);

src/OpenGl/OpenGl_Workspace.hxx

@@ -62,7 +62,8 @@ public:
   //! Checks whether the element can be rendered or not.
   //! @param theElement [in] the element to check.
   //! @return True if element can be rendered.
-  virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) Standard_OVERRIDE;
+  virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+                                         const OpenGl_Element*           theElement) Standard_OVERRIDE;
 
 private:
 

src/RWStepAP214/RWStepAP214_GeneralModule.cxx

@@ -1097,19 +1097,6 @@
 #include <StepVisual_ViewVolume.hxx>
 #include <TCollection_HAsciiString.hxx>
 
-#include <StepVisual_TessellatedAnnotationOccurrence.hxx>
-#include <StepVisual_TessellatedItem.hxx>
-#include <StepVisual_TessellatedGeometricSet.hxx>
-#include <StepVisual_TessellatedCurveSet.hxx>
-#include <StepVisual_CoordinatesList.hxx>
-
-#include <RWStepVisual_RWTessellatedAnnotationOccurrence.hxx>
-#include <RWStepVisual_RWTessellatedItem.hxx>
-#include <RWStepVisual_RWTessellatedGeometricSet.hxx>
-#include <RWStepVisual_RWTessellatedCurveSet.hxx>
-#include <RWStepVisual_RWCoordinatesList.hxx>
-
-
 IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_GeneralModule,StepData_GeneralModule)
 
 //#define DeclareAndCast(atype,result,start) \  NON car Name
@@ -1363,6 +1350,14 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_GeneralModule,StepData_GeneralModule)
 #include <StepVisual_AnnotationFillAreaOccurrence.hxx>
 #include <RWStepVisual_RWAnnotationFillArea.hxx>
 #include <RWStepVisual_RWAnnotationFillAreaOccurrence.hxx>
+#include <StepVisual_CameraModelD3MultiClipping.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClipping.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClippingIntersection.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx>
+#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+#include <RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
 
 static Standard_Integer catsh,catdr,catstr,catdsc,cataux;
 
@@ -5135,6 +5130,34 @@ void RWStepAP214_GeneralModule::FillSharedCase(const Standard_Integer CN,
     RWStepVisual_RWCharacterizedObjectAndCharacterizedRepresentationAndDraughtingModelAndRepresentation tool;
     tool.Share(anent, iter);
   }
+  break;
+  case 716:
+  {
+    DeclareAndCast(StepVisual_CameraModelD3MultiClipping, anent, ent);
+    RWStepVisual_RWCameraModelD3MultiClipping tool;
+    tool.Share(anent, iter);
+  }
+  break;
+  case 717:
+  {
+    DeclareAndCast(StepVisual_CameraModelD3MultiClippingIntersection, anent, ent);
+    RWStepVisual_RWCameraModelD3MultiClippingIntersection tool;
+    tool.Share(anent, iter);
+  }
+  break;
+  case 718:
+  {
+    DeclareAndCast(StepVisual_CameraModelD3MultiClippingUnion, anent, ent);
+    RWStepVisual_RWCameraModelD3MultiClippingUnion tool;
+    tool.Share(anent, iter);
+  }
+  break;
+  case 719:
+  {
+    DeclareAndCast(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, anent, ent);
+    RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem tool;
+    tool.Share(anent, iter);
+  }
   break;
     default : break;
     }
@@ -7136,6 +7159,18 @@ Standard_Boolean RWStepAP214_GeneralModule::NewVoid
    case 715:
    ent = new StepVisual_CharacterizedObjectAndCharacterizedRepresentationAndDraughtingModelAndRepresentation;
    break;
+   case 716:
+     ent = new StepVisual_CameraModelD3MultiClipping;
+   break;
+   case 717:
+     ent = new StepVisual_CameraModelD3MultiClippingIntersection;
+   break;
+   case 718:
+     ent = new StepVisual_CameraModelD3MultiClippingUnion;
+   break;
+   case 719:
+     ent = new StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem;
+   break;
 
     
   default: 
@@ -7732,6 +7767,10 @@ Standard_Integer  RWStepAP214_GeneralModule::CategoryNumber
   case 713: return catsh;
   case 714: return catstr;
   case 715: return catdsc;
+  case 716:
+  case 717:
+  case 718: return cataux;
+  case 719: return catdr;
     
   default : break;
   }

src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx

@@ -1398,6 +1398,14 @@ Handle(atype) result = Handle(atype)::DownCast (start)
 #include <StepVisual_AnnotationFillAreaOccurrence.hxx>
 #include <RWStepVisual_RWAnnotationFillArea.hxx>
 #include <RWStepVisual_RWAnnotationFillAreaOccurrence.hxx>
+#include <StepVisual_CameraModelD3MultiClipping.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClipping.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClippingIntersection.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx>
+#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+#include <RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
 
 
 // -- General Declarations (Recognize, StepType) ---
@@ -2037,6 +2045,9 @@ static TCollection_AsciiString Reco_CoordinatesList("COORDINATES_LIST");
 static TCollection_AsciiString Reco_ConstructiveGeometryRepresentation("CONSTRUCTIVE_GEOMETRY_REPRESENTATION");
 static TCollection_AsciiString Reco_ConstructiveGeometryRepresentationRelationship("CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP");
 static TCollection_AsciiString Reco_CharacterizedRepresentation("CHARACTERIZED_REPRESENTATION");
+static TCollection_AsciiString Reco_CameraModelD3MultiClipping("CAMERA_MODEL_D3_MULTI_CLIPPING");
+static TCollection_AsciiString Reco_CameraModelD3MultiClippingIntersection("CAMERA_MODEL_D3_MULTI_CLIPPING_INTERSECTION");
+static TCollection_AsciiString Reco_CameraModelD3MultiClippingUnion("CAMERA_MODEL_D3_MULTI_CLIPPING_UNION");
 // -- Definition of the libraries --
 
 static NCollection_DataMap<TCollection_AsciiString, Standard_Integer> typenums;
@@ -2690,6 +2701,9 @@ RWStepAP214_ReadWriteModule::RWStepAP214_ReadWriteModule ()
   typenums.Bind ( Reco_ConstructiveGeometryRepresentation, 712);
   typenums.Bind ( Reco_ConstructiveGeometryRepresentationRelationship, 713);
   typenums.Bind ( Reco_CharacterizedRepresentation, 714);
+  typenums.Bind ( Reco_CameraModelD3MultiClipping, 716);
+  typenums.Bind ( Reco_CameraModelD3MultiClippingIntersection, 717);
+  typenums.Bind ( Reco_CameraModelD3MultiClippingUnion, 718);
 
   
 //    SHORT NAMES
@@ -3450,6 +3464,13 @@ Standard_Integer RWStepAP214_ReadWriteModule::CaseStep
                  types(5).IsEqual(StepType(624))))) {
         return 705;
       }
+      if ((types(1).IsEqual(StepType(4))) &&
+          (types(2).IsEqual(StepType(7))) &&
+          (types(3).IsEqual(StepType(144))) &&
+          (types(4).IsEqual(StepType(247))) &&
+          (types(5).IsEqual(StepType(270)))) {
+        return 719;
+      }
     }
     else if (NbComp == 4) {
       if ((types(1).IsEqual(StepType(161))) &&
@@ -3864,6 +3885,8 @@ Standard_Boolean RWStepAP214_ReadWriteModule::IsComplex
       return Standard_True;
     case 715:
       return Standard_True;
+    case 719:
+      return Standard_True;
     default:
       return Standard_False;
     }
@@ -4519,6 +4542,9 @@ const TCollection_AsciiString& RWStepAP214_ReadWriteModule::StepType
   case 712 : return Reco_ConstructiveGeometryRepresentation;
   case 713 : return Reco_ConstructiveGeometryRepresentationRelationship;
   case 714 : return Reco_CharacterizedRepresentation;
+  case 716 : return Reco_CameraModelD3MultiClipping;
+  case 717 : return Reco_CameraModelD3MultiClippingIntersection;
+  case 718 : return Reco_CameraModelD3MultiClippingUnion;
 
   default : return PasReco;
   }
@@ -4833,6 +4859,14 @@ Standard_Boolean RWStepAP214_ReadWriteModule::ComplexType(const Standard_Integer
       types.Append(StepType(714));
       types.Append(StepType(441));
       types.Append(StepType(245));
+      break;
+    case 719:
+      types.Append(StepType(4));
+      types.Append(StepType(7));
+      types.Append(StepType(144));
+      types.Append(StepType(247));
+      types.Append(StepType(270));
+      break;
     }
   return Standard_True;
 }
@@ -9383,6 +9417,35 @@ void RWStepAP214_ReadWriteModule::ReadStep(const Standard_Integer CN,
       tool.ReadStep(data, num, ach, anent);
     }
     break;
+     case 716:
+   {
+     DeclareAndCast(StepVisual_CameraModelD3MultiClipping, anent, ent);
+     RWStepVisual_RWCameraModelD3MultiClipping tool;
+     tool.ReadStep(data, num, ach, anent);
+   }
+   break;
+     case 717:
+   {
+     DeclareAndCast(StepVisual_CameraModelD3MultiClippingIntersection, anent, ent);
+     RWStepVisual_RWCameraModelD3MultiClippingIntersection tool;
+     tool.ReadStep(data, num, ach, anent);
+   }
+   break;
+     case 718:
+   {
+     DeclareAndCast(StepVisual_CameraModelD3MultiClippingUnion, anent, ent);
+     RWStepVisual_RWCameraModelD3MultiClippingUnion tool;
+     tool.ReadStep(data, num, ach, anent);
+   }
+   break;
+     case 719:
+   {
+     DeclareAndCast(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, anent, ent);
+     RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem tool;
+     tool.ReadStep(data, num, ach, anent);
+   }
+   break;
+   
 
   default: 
     ach->AddFail("Type Mismatch when reading - Entity");
@@ -14211,6 +14274,34 @@ void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN,
       tool.WriteStep(SW, anent);
     }
     break;
+      case 716:
+    {
+      DeclareAndCast(StepVisual_CameraModelD3MultiClipping, anent, ent);
+      RWStepVisual_RWCameraModelD3MultiClipping tool;
+      tool.WriteStep(SW, anent);
+    }
+    break;
+      case 717:
+    {
+      DeclareAndCast(StepVisual_CameraModelD3MultiClippingIntersection, anent, ent);
+      RWStepVisual_RWCameraModelD3MultiClippingIntersection tool;
+      tool.WriteStep(SW, anent);
+    }
+    break;
+      case 718:
+    {
+      DeclareAndCast(StepVisual_CameraModelD3MultiClippingUnion, anent, ent);
+      RWStepVisual_RWCameraModelD3MultiClippingUnion tool;
+      tool.WriteStep(SW, anent);
+    }
+    break;
+      case 719:
+    {
+      DeclareAndCast(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, anent, ent);
+      RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem tool;
+      tool.WriteStep(SW, anent);
+    }
+      break;
 
   default: 
     return;

src/RWStepVisual/FILES

@@ -1,5 +1,7 @@
 RWStepVisual_RWAnnotationCurveOccurrence.cxx
 RWStepVisual_RWAnnotationCurveOccurrence.hxx
+RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.cxx
+RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx
 RWStepVisual_RWAnnotationFillArea.cxx
 RWStepVisual_RWAnnotationFillArea.hxx
 RWStepVisual_RWAnnotationFillAreaOccurrence.cxx
@@ -20,6 +22,12 @@ RWStepVisual_RWCameraModelD2.cxx
 RWStepVisual_RWCameraModelD2.hxx
 RWStepVisual_RWCameraModelD3.cxx
 RWStepVisual_RWCameraModelD3.hxx
+RWStepVisual_RWCameraModelD3MultiClipping.cxx
+RWStepVisual_RWCameraModelD3MultiClipping.hxx
+RWStepVisual_RWCameraModelD3MultiClippingIntersection.cxx
+RWStepVisual_RWCameraModelD3MultiClippingIntersection.hxx
+RWStepVisual_RWCameraModelD3MultiClippingUnion.cxx
+RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx
 RWStepVisual_RWCameraUsage.cxx
 RWStepVisual_RWCameraUsage.hxx
 RWStepVisual_RWCharacterizedObjectAndCharacterizedRepresentationAndDraughtingModelAndRepresentation.cxx

src/RWStepVisual/RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.cxx

@@ -0,0 +1,114 @@
+// Created on: 2017-02-06
+// Created by: Irina KRYLOVA
+// Copyright (c) 2017 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.
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepVisual_HArray1OfPresentationStyleAssignment.hxx>
+#include <StepVisual_PresentationStyleAssignment.hxx>
+#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+
+//=======================================================================
+//function : RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem
+//purpose  : 
+//=======================================================================
+RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem::
+  RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem () {}
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem::ReadStep
+(const Handle(StepData_StepReaderData)& data,
+const Standard_Integer num0,
+Handle(Interface_Check)& ach,
+const Handle(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem)& ent) const
+{
+  Standard_Integer num = 0;
+  data->NamedForComplex("REPRESENTATION_ITEM", "RPRITM", num0, num, ach);
+  // Inherited field : name 
+  Handle(TCollection_HAsciiString) aName;
+  data->ReadString(num, 1, "name", ach, aName);
+
+  data->NamedForComplex("STYLED_ITEM", "STYITM", num0, num, ach);
+  // Inherited field : styles
+  Handle(StepVisual_HArray1OfPresentationStyleAssignment) aStyles;
+  Handle(StepVisual_PresentationStyleAssignment) anEnt;
+  Standard_Integer nsub;
+  if (data->ReadSubList(num, 1, "styles", ach, nsub)) {
+    Standard_Integer nb = data->NbParams(nsub);
+    aStyles = new StepVisual_HArray1OfPresentationStyleAssignment(1, nb);
+    for (Standard_Integer i = 1; i <= nb; i++) {
+      if (data->ReadEntity(nsub, i, "presentation_style_assignment", ach,
+        STANDARD_TYPE(StepVisual_PresentationStyleAssignment), anEnt))
+        aStyles->SetValue(i, anEnt);
+    }
+  }
+
+  // Inherited field : item
+  Handle(MMgt_TShared) aItem;
+  data->ReadEntity(num, 2, "item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+
+  // Initialization of the read entity
+  ent->Init(aName, aStyles, aItem);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem::WriteStep
+(StepData_StepWriter& SW,
+const Handle(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem)& ent) const
+{
+  SW.StartEntity("ANNOTATION_CURVE_OCCURRENCE");
+  SW.StartEntity("ANNOTATION_OCCURRENCE");
+  SW.StartEntity("GEOMETRIC_REPRESENTATION_ITEM");
+  SW.StartEntity("REPRESENTATION_ITEM");
+  //Inherited field : name
+  SW.Send(ent->Name());
+
+  SW.StartEntity("STYLED_ITEM");
+  // Inherited field : styles
+  SW.OpenSub();
+  for (Standard_Integer i = 1; i <= ent->NbStyles(); i++) {
+    SW.Send(ent->StylesValue(i));
+  }
+  SW.CloseSub();
+
+  // Inherited field : item
+  SW.Send(ent->Item());
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem::Share(
+  const Handle(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem)& ent,
+  Interface_EntityIterator& iter) const
+{
+
+  Standard_Integer nbElem = ent->NbStyles();
+  for (Standard_Integer i = 1; i <= nbElem; i++) {
+    iter.GetOneItem(ent->StylesValue(i));
+  }
+
+  iter.GetOneItem(ent->Item());
+}

src/RWStepVisual/RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx

@@ -0,0 +1,45 @@
+// Created on: 2017-02-06
+// Created by: Irina KRYLOVA
+// Copyright (c) 2017 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 _RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem_HeaderFile
+#define _RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+//! Read & Write Module for AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem
+class RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem 
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  Standard_EXPORT RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem();
+  
+  Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem)& ent) const;
+  
+  Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem)& ent) const;
+  
+  Standard_EXPORT void Share (const Handle(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem_HeaderFile

src/RWStepVisual/RWStepVisual_RWCameraModelD3MultiClipping.cxx

@@ -0,0 +1,118 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClipping.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
+#include <StepVisual_CameraModelD3MultiClipping.hxx>
+#include <StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx>
+#include <StepVisual_ViewVolume.hxx>
+
+//=======================================================================
+//function : RWStepVisual_RWCameraModelD3MultiClipping
+//purpose  : 
+//=======================================================================
+RWStepVisual_RWCameraModelD3MultiClipping::RWStepVisual_RWCameraModelD3MultiClipping() {}
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClipping::ReadStep
+  (const Handle(StepData_StepReaderData)& data,
+   const Standard_Integer num,
+   Handle(Interface_Check)& ach,
+   const Handle(StepVisual_CameraModelD3MultiClipping)& ent) const
+{
+  // Number of Parameter Control
+  if (!data->CheckNbParams(num, 4, ach, "camera_model_d3_multi_clipping"))
+    return;
+
+  // Inherited field : name
+  Handle(TCollection_HAsciiString) aName;
+  data->ReadString (num, 1, "name", ach, aName);
+
+  //Inherited field : view_reference_system
+  Handle(StepGeom_Axis2Placement3d) aViewReferenceSystem;
+  data->ReadEntity(num, 2, "view_reference_system", ach, STANDARD_TYPE(StepGeom_Axis2Placement3d), aViewReferenceSystem);
+
+  // Inherited field : perspective_of_volume
+  Handle(StepVisual_ViewVolume) aPerspectiveOfVolume;
+  data->ReadEntity(num, 3, "perspective_of_volume", ach, STANDARD_TYPE(StepVisual_ViewVolume), aPerspectiveOfVolume);
+
+  // Own field : shape_clipping
+  Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect) aShapeClipping;
+  StepVisual_CameraModelD3MultiClippingInterectionSelect anEnt;
+  Standard_Integer nbSub;
+  if (data->ReadSubList(num, 4, "shape_clipping", ach, nbSub)) {
+    Standard_Integer nbElements = data->NbParams(nbSub);
+    aShapeClipping = new StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect(1, nbElements);
+    for (Standard_Integer i = 1; i <= nbElements; i++) {
+      if (data->ReadEntity(nbSub, i, "shape_clipping", ach, anEnt))
+        aShapeClipping->SetValue(i, anEnt);
+    }
+  }
+
+  // Initialization of the read entity
+  ent->Init(aName, aViewReferenceSystem, aPerspectiveOfVolume, aShapeClipping);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClipping::WriteStep
+  (StepData_StepWriter& SW,
+   const Handle(StepVisual_CameraModelD3MultiClipping)& ent) const
+{
+  // Inherited field name
+  SW.Send(ent->Name());
+
+  // Inherited field view_reference_system
+  SW.Send(ent->ViewReferenceSystem());
+
+  // Inherited field view_reference_system
+  SW.Send(ent->PerspectiveOfVolume());
+
+  // Own field: shape_clipping
+  SW.OpenSub();
+  for (Standard_Integer i = 1; i <= ent->ShapeClipping()->Length(); i++) {
+    SW.Send(ent->ShapeClipping()->Value(i).Value());
+  }
+  SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClipping::Share
+  (const Handle(StepVisual_CameraModelD3MultiClipping)& ent,
+   Interface_EntityIterator& iter) const
+{
+  // Inherited field view_reference_system
+  iter.GetOneItem(ent->ViewReferenceSystem());
+  // Inherited field : perspective_of_volume
+  iter.GetOneItem(ent->PerspectiveOfVolume());
+  // Own field: shape_clipping
+  Standard_Integer i, nb = ent->ShapeClipping()->Length();
+  for (i = 1; i <= nb; i++)
+    iter.AddItem(ent->ShapeClipping()->Value(i).Value());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraModelD3MultiClipping.hxx

@@ -0,0 +1,48 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _RWStepVisual_RWCameraModelD3MultiClipping_HeaderFile
+#define _RWStepVisual_RWCameraModelD3MultiClipping_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepVisual_CameraModelD3MultiClipping;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+//! Read & Write Module for CameraModelD3MultiClipping
+class RWStepVisual_RWCameraModelD3MultiClipping
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  Standard_EXPORT RWStepVisual_RWCameraModelD3MultiClipping();
+  
+  Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data,
+                                 const Standard_Integer num,
+                                 Handle(Interface_Check)& ach,
+                                 const Handle(StepVisual_CameraModelD3MultiClipping)& ent) const;
+  
+  Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepVisual_CameraModelD3MultiClipping)& ent) const;
+  
+  Standard_EXPORT void Share(const Handle(StepVisual_CameraModelD3MultiClipping)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepVisual_RWCameraModelD3MultiClipping_HeaderFile

src/RWStepVisual/RWStepVisual_RWCameraModelD3MultiClippingIntersection.cxx

@@ -0,0 +1,98 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClippingIntersection.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+#include <StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx>
+
+//=======================================================================
+//function : RWStepVisual_RWCameraModelD3MultiClippingIntersection
+//purpose  : 
+//=======================================================================
+RWStepVisual_RWCameraModelD3MultiClippingIntersection::RWStepVisual_RWCameraModelD3MultiClippingIntersection() {}
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClippingIntersection::ReadStep
+  (const Handle(StepData_StepReaderData)& data,
+   const Standard_Integer num,
+   Handle(Interface_Check)& ach,
+   const Handle(StepVisual_CameraModelD3MultiClippingIntersection)& ent) const
+{
+  // Number of Parameter Control
+  if (!data->CheckNbParams(num, 2, ach, "camera_model_d3_multi_clipping_intersection"))
+    return;
+
+  // Inherited field : name
+  Handle(TCollection_HAsciiString) aName;
+  data->ReadString (num, 1, "name", ach, aName);
+
+  // Own field : shape_clipping
+  Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect) aShapeClipping;
+  StepVisual_CameraModelD3MultiClippingInterectionSelect anEnt;
+  Standard_Integer nbSub;
+  if (data->ReadSubList(num, 2, "shape_clipping", ach, nbSub)) {
+    Standard_Integer nbElements = data->NbParams(nbSub);
+    aShapeClipping = new StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect(1, nbElements);
+    for (Standard_Integer i = 1; i <= nbElements; i++) {
+      if (data->ReadEntity(nbSub, i, "shape_clipping", ach, anEnt))
+        aShapeClipping->SetValue(i, anEnt);
+    }
+  }
+
+  // Initialization of the read entity
+  ent->Init(aName, aShapeClipping);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClippingIntersection::WriteStep
+  (StepData_StepWriter& SW,
+   const Handle(StepVisual_CameraModelD3MultiClippingIntersection)& ent) const
+{
+  // Inherited field name
+  SW.Send(ent->Name());
+
+  // Own field: shape_clipping
+  SW.OpenSub();
+  for (Standard_Integer i = 1; i <= ent->ShapeClipping()->Length(); i++) {
+    SW.Send(ent->ShapeClipping()->Value(i).Value());
+  }
+  SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClippingIntersection::Share
+  (const Handle(StepVisual_CameraModelD3MultiClippingIntersection)& ent,
+   Interface_EntityIterator& iter) const
+{
+  // Own field: shape_clipping
+  Standard_Integer i, nb = ent->ShapeClipping()->Length();
+  for (i = 1; i <= nb; i++)
+    iter.AddItem(ent->ShapeClipping()->Value(i).Value());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraModelD3MultiClippingIntersection.hxx

@@ -0,0 +1,48 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _RWStepVisual_RWCameraModelD3MultiClippingIntersection_HeaderFile
+#define _RWStepVisual_RWCameraModelD3MultiClippingIntersection_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepVisual_CameraModelD3MultiClippingIntersection;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+//! Read & Write Module for CameraModelD3MultiClippingIntersection
+class RWStepVisual_RWCameraModelD3MultiClippingIntersection
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  Standard_EXPORT RWStepVisual_RWCameraModelD3MultiClippingIntersection();
+  
+  Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data,
+                                 const Standard_Integer num,
+                                 Handle(Interface_Check)& ach,
+                                 const Handle(StepVisual_CameraModelD3MultiClippingIntersection)& ent) const;
+  
+  Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepVisual_CameraModelD3MultiClippingIntersection)& ent) const;
+  
+  Standard_EXPORT void Share(const Handle(StepVisual_CameraModelD3MultiClippingIntersection)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepVisual_RWCameraModelD3MultiClippingIntersection_HeaderFile

src/RWStepVisual/RWStepVisual_RWCameraModelD3MultiClippingUnion.cxx

@@ -0,0 +1,98 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+#include <StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx>
+
+//=======================================================================
+//function : RWStepVisual_RWCameraModelD3MultiClippingUnion
+//purpose  : 
+//=======================================================================
+RWStepVisual_RWCameraModelD3MultiClippingUnion::RWStepVisual_RWCameraModelD3MultiClippingUnion() {}
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClippingUnion::ReadStep
+  (const Handle(StepData_StepReaderData)& data,
+   const Standard_Integer num,
+   Handle(Interface_Check)& ach,
+   const Handle(StepVisual_CameraModelD3MultiClippingUnion)& ent) const
+{
+  // Number of Parameter Control
+  if (!data->CheckNbParams(num, 2, ach, "camera_model_d3_multi_clipping_union"))
+    return;
+
+  // Inherited field : name
+  Handle(TCollection_HAsciiString) aName;
+  data->ReadString (num, 1, "name", ach, aName);
+
+  // Own field : shape_clipping
+  Handle(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect) aShapeClipping;
+  StepVisual_CameraModelD3MultiClippingUnionSelect anEnt;
+  Standard_Integer nbSub;
+  if (data->ReadSubList(num, 2, "shape_clipping", ach, nbSub)) {
+    Standard_Integer nbElements = data->NbParams(nbSub);
+    aShapeClipping = new StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect(1, nbElements);
+    for (Standard_Integer i = 1; i <= nbElements; i++) {
+      if (data->ReadEntity(nbSub, i, "shape_clipping", ach, anEnt))
+        aShapeClipping->SetValue(i, anEnt);
+    }
+  }
+
+  // Initialization of the read entity
+  ent->Init(aName, aShapeClipping);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClippingUnion::WriteStep
+  (StepData_StepWriter& SW,
+   const Handle(StepVisual_CameraModelD3MultiClippingUnion)& ent) const
+{
+  // Inherited field name
+  SW.Send(ent->Name());
+
+  // Own field: shape_clipping
+  SW.OpenSub();
+  for (Standard_Integer i = 1; i <= ent->ShapeClipping()->Length(); i++) {
+    SW.Send(ent->ShapeClipping()->Value(i).Value());
+  }
+  SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+void RWStepVisual_RWCameraModelD3MultiClippingUnion::Share
+  (const Handle(StepVisual_CameraModelD3MultiClippingUnion)& ent,
+   Interface_EntityIterator& iter) const
+{
+  // Own field: shape_clipping
+  Standard_Integer i, nb = ent->ShapeClipping()->Length();
+  for (i = 1; i <= nb; i++)
+    iter.AddItem(ent->ShapeClipping()->Value(i).Value());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx

@@ -0,0 +1,48 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _RWStepVisual_RWCameraModelD3MultiClippingUnion_HeaderFile
+#define _RWStepVisual_RWCameraModelD3MultiClippingUnion_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepVisual_CameraModelD3MultiClippingUnion;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+//! Read & Write Module for CameraModelD3MultiClippingUnion
+class RWStepVisual_RWCameraModelD3MultiClippingUnion
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  Standard_EXPORT RWStepVisual_RWCameraModelD3MultiClippingUnion();
+  
+  Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data,
+                                 const Standard_Integer num,
+                                 Handle(Interface_Check)& ach,
+                                 const Handle(StepVisual_CameraModelD3MultiClippingUnion)& ent) const;
+  
+  Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepVisual_CameraModelD3MultiClippingUnion)& ent) const;
+  
+  Standard_EXPORT void Share(const Handle(StepVisual_CameraModelD3MultiClippingUnion)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepVisual_RWCameraModelD3MultiClippingUnion_HeaderFile

src/STEPCAFControl/STEPCAFControl_Reader.cxx

@@ -16,6 +16,8 @@
 
 #include <BRep_Builder.hxx>
 #include <Geom_Axis2Placement.hxx>
+#include <Geom_CartesianPoint.hxx>
+#include <Geom_Plane.hxx>
 #include <Interface_EntityIterator.hxx>
 #include <Interface_InterfaceModel.hxx>
 #include <StepData_StepModel.hxx>
@@ -37,6 +39,7 @@
 #include <StepBasic_ProductDefinition.hxx>
 #include <StepBasic_ProductDefinitionFormation.hxx>
 #include <StepBasic_ProductDefinitionRelationship.hxx>
+#include <StepBasic_ProductDefinitionWithAssociatedDocuments.hxx>
 #include <StepBasic_SiUnit.hxx>
 #include <StepBasic_SiUnitAndLengthUnit.hxx>
 #include <StepBasic_Unit.hxx>
@@ -109,6 +112,7 @@
 #include <StepRepr_DerivedShapeAspect.hxx>
 #include <StepRepr_DescriptiveRepresentationItem.hxx>
 #include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_MappedItem.hxx>
 #include <StepRepr_MeasureRepresentationItem.hxx>
 #include <StepRepr_NextAssemblyUsageOccurrence.hxx>
 #include <StepRepr_ProductDefinitionShape.hxx>
@@ -117,6 +121,7 @@
 #include <StepRepr_Representation.hxx>
 #include <StepRepr_RepresentationItem.hxx>
 #include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationMap.hxx>
 #include <StepRepr_RepresentationRelationship.hxx>
 #include <StepRepr_RepresentedDefinition.hxx>
 #include <StepRepr_ReprItemAndLengthMeasureWithUnit.hxx>
@@ -177,6 +182,13 @@
 #include <StepVisual_AnnotationCurveOccurrence.hxx>
 #include <StepVisual_AnnotationFillArea.hxx>
 #include <StepVisual_AnnotationPlane.hxx>
+#include <StepVisual_CameraModelD3.hxx>
+#include <StepVisual_CameraModelD3MultiClipping.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+#include <StepVisual_CoordinatesList.hxx>
+#include <StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx>
+#include <StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx>
 #include <StepVisual_DraughtingCallout.hxx>
 #include <StepVisual_DraughtingCalloutElement.hxx>
 #include <StepVisual_DraughtingModel.hxx>
@@ -187,6 +199,7 @@
 #include <StepVisual_PresentationStyleByContext.hxx>
 #include <StepVisual_StyleContextSelect.hxx>
 #include <StepVisual_StyledItem.hxx>
+#include <StepVisual_ViewVolume.hxx>
 #include <StepShape_TypeQualifier.hxx>
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_HAsciiString.hxx>
@@ -218,6 +231,7 @@
 #include <XCAFDoc.hxx>
 #include <XCAFDoc_Area.hxx>
 #include <XCAFDoc_Centroid.hxx>
+#include <XCAFDoc_ClippingPlaneTool.hxx>
 #include <XCAFDoc_ColorTool.hxx>
 #include <XCAFDoc_DataMapOfShapeLabel.hxx>
 #include <XCAFDoc_DimTolTool.hxx>
@@ -229,12 +243,15 @@
 #include <XCAFDoc_LayerTool.hxx>
 #include <XCAFDoc_MaterialTool.hxx>
 #include <XCAFDoc_ShapeTool.hxx>
+#include <XCAFDoc_View.hxx>
+#include <XCAFDoc_ViewTool.hxx>
 #include <XCAFDoc_Volume.hxx>
 #include <XCAFDimTolObjects_DimensionModifiersSequence.hxx>
 #include <XCAFDimTolObjects_GeomToleranceType.hxx>
 #include <XCAFDimTolObjects_DimensionObject.hxx>
 #include <XCAFDimTolObjects_GeomToleranceObject.hxx>
 #include <XCAFDimTolObjects_DatumObject.hxx>
+#include <XCAFView_Object.hxx>
 #include <XSControl_TransferReader.hxx>
 #include <XSControl_WorkSession.hxx>
 #include <StepAP242_DraughtingModelItemAssociation.hxx>
@@ -321,7 +338,8 @@ STEPCAFControl_Reader::STEPCAFControl_Reader ():
        myPropsMode( Standard_True ),
 	   mySHUOMode ( Standard_False ),
        myGDTMode  ( Standard_True ),
-       myMatMode  ( Standard_True )
+       myMatMode(Standard_True),
+       myViewMode(Standard_True)
 {
   STEPCAFControl_Controller::Init();
 }
@@ -340,7 +358,8 @@ STEPCAFControl_Reader::STEPCAFControl_Reader (const Handle(XSControl_WorkSession
        myPropsMode( Standard_True ),
 	   mySHUOMode ( Standard_False ),
        myGDTMode  ( Standard_True ),
-       myMatMode  ( Standard_True )
+       myMatMode(Standard_True),
+       myViewMode(Standard_True)
 {
   STEPCAFControl_Controller::Init();
   Init ( WS, scratch );
@@ -685,6 +704,10 @@ Standard_Boolean STEPCAFControl_Reader::Transfer (STEPControl_Reader &reader,
   if(GetMatMode())
     ReadMaterials(reader.WS(),doc,SeqPDS);
 
+  // read View entities from STEP model
+  if (GetViewMode())
+    ReadViews(reader.WS(), doc);
+
   // Expand resulting CAF structure for sub-shapes (optionally with their
   // names) if requested
   ExpandSubShapes(STool, map, ShapePDMap);
@@ -1155,6 +1178,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadNames (const Handle(XSControl_WorkSe
   Standard_Integer nb = Model->NbEntities();
   Handle(Standard_Type) tNAUO = STANDARD_TYPE(StepRepr_NextAssemblyUsageOccurrence);
   Handle(Standard_Type) tPD  = STANDARD_TYPE(StepBasic_ProductDefinition);
+  Handle(Standard_Type) tPDWAD = STANDARD_TYPE(StepBasic_ProductDefinitionWithAssociatedDocuments);
   Handle(TCollection_HAsciiString) name;
   TDF_Label L;
   for (Standard_Integer i = 1; i <= nb; i++) {
@@ -1187,7 +1211,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadNames (const Handle(XSControl_WorkSe
     }
 
     // for PD get name of associated product
-    if ( enti->DynamicType() == tPD ) {
+    if (enti->DynamicType() == tPD || enti->DynamicType() == tPDWAD) {
       L.Nullify();
       Handle(StepBasic_ProductDefinition) PD = 
         Handle(StepBasic_ProductDefinition)::DownCast(enti);
@@ -1926,7 +1950,6 @@ Standard_Boolean readAnnotationPlane(const Handle(StepVisual_AnnotationPlane) th
 {
   if (theAnnotationPlane.IsNull())
     return Standard_False;
-  gp_Ax2 aPlaneAxes;
   Handle(StepRepr_RepresentationItem) aPlaneItem = theAnnotationPlane->Item();
   if (aPlaneItem.IsNull())
     return Standard_False;
@@ -1943,23 +1966,11 @@ Standard_Boolean readAnnotationPlane(const Handle(StepVisual_AnnotationPlane) th
   if (aA2P3D.IsNull())
     return Standard_False;
 
-  // build gp_Ax2 from axes
-  Handle(StepGeom_Direction) anAxis = aA2P3D->Axis(),
-    aRefDir = aA2P3D->RefDirection();
-  if (anAxis.IsNull() || aRefDir.IsNull())
-    return Standard_False;
-
-  Handle(TColStd_HArray1OfReal) aCoords;
-  aCoords = anAxis->DirectionRatios();
-  gp_Dir aXDir(aCoords->Value(1), aCoords->Value(2), aCoords->Value(3));
-  aCoords = aRefDir->DirectionRatios();
-  gp_Dir aYDir(aCoords->Value(1), aCoords->Value(2), aCoords->Value(3));
-  aPlaneAxes.SetDirection(aXDir.Crossed(aYDir));
-  aPlaneAxes.SetYDirection(aYDir);
-  //set location of the annotation plane
-  Handle(TColStd_HArray1OfReal) aLocCoords;
-  Handle(StepGeom_CartesianPoint) aLoc = aA2P3D->Location();
-  gp_Pnt aLocPos(aLoc->CoordinatesValue(1) * theFact, aLoc->CoordinatesValue(2) * theFact, aLoc->CoordinatesValue(3) * theFact);
+  gp_Ax2 aPlaneAxes;
+  Handle(Geom_Axis2Placement) anAxis = StepToGeom::MakeAxis2Placement(aA2P3D);
+  aPlaneAxes = anAxis->Ax2();
+  gp_XYZ aLocPos = aPlaneAxes.Location().XYZ();
+  aLocPos *= theFact;
   aPlaneAxes.SetLocation(aLocPos);
   thePlane = aPlaneAxes;
   return Standard_True;
@@ -2346,14 +2357,14 @@ static TDF_Label getShapeLabel(const Handle(StepRepr_RepresentationItem)& theIte
 //purpose  : 
 //=======================================================================
 
-static Standard_Boolean setDatumToXCAF(const Handle(StepDimTol_Datum)& theDat,
-                                       const TDF_Label theGDTL,
-                                       const Standard_Integer thePositionCounter,
-                                       const XCAFDimTolObjects_DatumModifiersSequence& theXCAFModifiers,
-                                       const XCAFDimTolObjects_DatumModifWithValue theXCAFModifWithVal,
-                                       const Standard_Real theModifValue,
-                                       const Handle(TDocStd_Document)& theDoc,
-                                       const Handle(XSControl_WorkSession)& theWS)
+Standard_Boolean STEPCAFControl_Reader::setDatumToXCAF(const Handle(StepDimTol_Datum)& theDat,
+                                                       const TDF_Label theGDTL,
+                                                       const Standard_Integer thePositionCounter,
+                                                       const XCAFDimTolObjects_DatumModifiersSequence& theXCAFModifiers,
+                                                       const XCAFDimTolObjects_DatumModifWithValue theXCAFModifWithVal,
+                                                       const Standard_Real theModifValue,
+                                                       const Handle(TDocStd_Document)& theDoc,
+                                                       const Handle(XSControl_WorkSession)& theWS)
 {
   Handle(XCAFDoc_ShapeTool) aSTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
   Handle(XCAFDoc_DimTolTool) aDGTTool = XCAFDoc_DocumentTool::DimTolTool(theDoc->Main());
@@ -2532,6 +2543,8 @@ static Standard_Boolean setDatumToXCAF(const Handle(StepDimTol_Datum)& theDat,
     // Create datum target object
     if (isValidDT) {
       TDF_Label aDatL = aDGTTool->AddDatum();
+      myGDTMap.Bind(aDT, aDatL);
+      aDGTTool->Lock(aDatL);
       aDat = XCAFDoc_Datum::Set(aDatL);
       aDGTTool->SetDatum(aDTShapeLabels, aDatL);
       aDatTargetObj->SetName(theDat->Identification());
@@ -2552,6 +2565,15 @@ static Standard_Boolean setDatumToXCAF(const Handle(StepDimTol_Datum)& theDat,
   if (aShapeLabels.Length() > 0 || !isExistDatumTarget) {
     // Create object for datum
     TDF_Label aDatL = aDGTTool->AddDatum();
+    myGDTMap.Bind(theDat, aDatL);
+    // bind datum label with all reference datum_feature entities
+    for (Standard_Integer i = 1; i <= aSAs.Length(); i++) {
+      Handle(StepRepr_ShapeAspect) aSA = aSAs.Value(i);
+      if (aSA.IsNull() || aSA->IsKind(STANDARD_TYPE(StepDimTol_DatumTarget)))
+        continue;
+      myGDTMap.Bind(aSA, aDatL);
+    }
+    aDGTTool->Lock(aDatL);
     aDat = XCAFDoc_Datum::Set(aDatL);
     aDGTTool->SetDatum(aShapeLabels, aDatL);
     aDatObj->SetName(theDat->Identification());
@@ -2576,10 +2598,10 @@ static Standard_Boolean setDatumToXCAF(const Handle(StepDimTol_Datum)& theDat,
 //function : ReadDatums
 //purpose  : auxilary
 //=======================================================================
-static Standard_Boolean readDatumsAP242(const Handle(Standard_Transient)& theEnt,
-                                        const TDF_Label theGDTL,
-                                        const Handle(TDocStd_Document)& theDoc,
-                                        const Handle(XSControl_WorkSession)& theWS)
+Standard_Boolean STEPCAFControl_Reader::readDatumsAP242(const Handle(Standard_Transient)& theEnt,
+                                                        const TDF_Label theGDTL,
+                                                        const Handle(TDocStd_Document)& theDoc,
+                                                        const Handle(XSControl_WorkSession)& theWS)
 {
   const Handle(XSControl_TransferReader) &aTR = theWS->TransferReader();
   const Handle(Transfer_TransientProcess) &aTP = aTR->TransientProcess();
@@ -2724,7 +2746,7 @@ static Standard_Boolean readDatumsAP242(const Handle(Standard_Transient)& theEnt
 //function : createGeomTolObjectInXCAF
 //purpose  : 
 //=======================================================================
-static TDF_Label createGDTObjectInXCAF(const Handle(Standard_Transient)& theEnt,
+TDF_Label STEPCAFControl_Reader::createGDTObjectInXCAF(const Handle(Standard_Transient)& theEnt,
                                                const Handle(TDocStd_Document)& theDoc,
                                                const Handle(XSControl_WorkSession)& theWS)
 {
@@ -3092,6 +3114,8 @@ static TDF_Label createGDTObjectInXCAF(const Handle(Standard_Transient)& theEnt,
     if(!theEnt->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance)))
     {
       aGDTL = aDGTTool->AddDimension();
+      myGDTMap.Bind(theEnt, aGDTL);
+      aDGTTool->Lock(aGDTL);
       Handle(XCAFDoc_Dimension) aDim = XCAFDoc_Dimension::Set(aGDTL);
       TCollection_AsciiString aStr("DGT:Dimensional_");
       if(theEnt->IsKind(STANDARD_TYPE(StepShape_DimensionalSize)))
@@ -3117,6 +3141,8 @@ static TDF_Label createGDTObjectInXCAF(const Handle(Standard_Transient)& theEnt,
     else
     {
       aGDTL = aDGTTool->AddGeomTolerance();
+      myGDTMap.Bind(theEnt, aGDTL);
+      aDGTTool->Lock(aGDTL);
       Handle(XCAFDoc_GeomTolerance) aGTol = XCAFDoc_GeomTolerance::Set(aGDTL);
       TCollection_AsciiString aStr("DGT:GeomTolerance");
       TDataStd_Name::Set(aGDTL, aStr);
@@ -3791,7 +3817,7 @@ static void setGeomTolObjectToXCAF(const Handle(Standard_Transient)& theEnt,
 //=======================================================================
 
 Standard_Boolean STEPCAFControl_Reader::ReadGDTs(const Handle(XSControl_WorkSession)& theWS,
-                                                 Handle(TDocStd_Document)& theDoc) const
+                                                 Handle(TDocStd_Document)& theDoc)
 {
   const Handle(Interface_InterfaceModel) &aModel = theWS->Model();
   const Interface_Graph& aGraph = theWS->Graph();
@@ -3920,6 +3946,8 @@ Standard_Boolean STEPCAFControl_Reader::ReadGDTs(const Handle(XSControl_WorkSess
       
       // Set object to XCAF
       TDF_Label aGDTL = aDGTTool->AddDimension();
+      myGDTMap.Bind(anEnt, aGDTL);
+      aDGTTool->Lock(aGDTL);
       Handle(XCAFDimTolObjects_DimensionObject) aDimObj = new XCAFDimTolObjects_DimensionObject();
       Handle(XCAFDoc_Dimension) aDim = XCAFDoc_Dimension::Set(aGDTL);
       TCollection_AsciiString aStr("DGT:");
@@ -4095,6 +4123,223 @@ Standard_Boolean STEPCAFControl_Reader::ReadMaterials(const Handle(XSControl_Wor
   return Standard_True;
 }
 
+//=======================================================================
+//function : collectViewShapes
+//purpose  : collect all labels of representations in given representation
+//=======================================================================
+
+void collectViewShapes(const Handle(XSControl_WorkSession)& theWS,
+  const Handle(TDocStd_Document)& theDoc,
+  const Handle(StepRepr_Representation) theRepr,
+  TDF_LabelSequence& theShapes)
+{
+  Handle(XSControl_TransferReader) aTR = theWS->TransferReader();
+  Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
+  const Interface_Graph& aGraph = aTP->Graph();
+  Handle(XCAFDoc_ShapeTool) aSTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
+  Standard_Integer anIndex = aTP->MapIndex(theRepr);
+  TopoDS_Shape aSh;
+  if (anIndex > 0) {
+    Handle(Transfer_Binder) aBinder = aTP->MapItem(anIndex);
+    aSh = TransferBRep::ShapeResult(aBinder);
+  }
+  if (!aSh.IsNull()) {
+    TDF_Label aShL;
+    aSTool->FindShape(aSh, aShL);
+    if (!aShL.IsNull())
+      theShapes.Append(aShL);
+  }
+  Interface_EntityIterator anIter = aGraph.Sharings(theRepr);
+  for (; anIter.More(); anIter.Next()) {
+    if (!anIter.Value()->IsKind(STANDARD_TYPE(StepRepr_RepresentationRelationship)))
+      continue;
+    Handle(StepRepr_RepresentationRelationship) aReprRelationship = Handle(StepRepr_RepresentationRelationship)::DownCast(anIter.Value());
+    if (aReprRelationship->Rep1() != theRepr)
+      collectViewShapes(theWS, theDoc, aReprRelationship->Rep1(), theShapes);
+  }
+}
+
+//=======================================================================
+//function : buildClippingPlanes
+//purpose  :
+//=======================================================================
+Handle(TCollection_HAsciiString) buildClippingPlanes(const Handle(StepGeom_GeometricRepresentationItem)& theClippingCameraModel,
+  TDF_LabelSequence& theClippingPlanes,
+  const Handle(XCAFDoc_ClippingPlaneTool) theTool)
+{
+  Handle(TCollection_HAsciiString) anExpression = new TCollection_HAsciiString();
+  NCollection_Sequence<Handle(StepGeom_GeometricRepresentationItem)> aPlanes;
+  Handle(TCollection_HAsciiString) anOperation = new TCollection_HAsciiString("*");
+
+  // Store operands
+  if (theClippingCameraModel->IsKind(STANDARD_TYPE(StepVisual_CameraModelD3MultiClipping))) {
+    Handle(StepVisual_CameraModelD3MultiClipping) aCameraModel =
+      Handle(StepVisual_CameraModelD3MultiClipping)::DownCast(theClippingCameraModel);
+    // Root of clipping planes tree
+    if (aCameraModel->ShapeClipping()->Length() == 1) {
+      Handle(StepVisual_CameraModelD3MultiClippingUnion) aCameraModelUnion =
+        aCameraModel->ShapeClipping()->Value(1).CameraModelD3MultiClippingUnion();
+      if (!aCameraModelUnion.IsNull())
+        return buildClippingPlanes(aCameraModelUnion, theClippingPlanes, theTool);
+    }
+    for (Standard_Integer i = 1; i <= aCameraModel->ShapeClipping()->Length(); i++) {
+      aPlanes.Append(Handle(StepGeom_GeometricRepresentationItem)::DownCast(aCameraModel->ShapeClipping()->Value(i).Value()));
+    }
+  }
+  else if (theClippingCameraModel->IsKind(STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingUnion))) {
+    Handle(StepVisual_CameraModelD3MultiClippingUnion) aCameraModel =
+      Handle(StepVisual_CameraModelD3MultiClippingUnion)::DownCast(theClippingCameraModel);
+    anOperation = new TCollection_HAsciiString("+");
+    for (Standard_Integer i = 1; i <= aCameraModel->ShapeClipping()->Length(); i++) {
+      aPlanes.Append(Handle(StepGeom_GeometricRepresentationItem)::DownCast(aCameraModel->ShapeClipping()->Value(i).Value()));
+    }
+  }
+  else if (theClippingCameraModel->IsKind(STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingIntersection))) {
+    Handle(StepVisual_CameraModelD3MultiClippingIntersection) aCameraModel =
+      Handle(StepVisual_CameraModelD3MultiClippingIntersection)::DownCast(theClippingCameraModel);
+    for (Standard_Integer i = 1; i <= aCameraModel->ShapeClipping()->Length(); i++) {
+      aPlanes.Append(Handle(StepGeom_GeometricRepresentationItem)::DownCast(aCameraModel->ShapeClipping()->Value(i).Value()));
+    }
+  }
+  // Build expression
+  anExpression->AssignCat("(");
+  for (Standard_Integer i = 1; i <= aPlanes.Length(); i++) {
+    Handle(StepGeom_Plane) aPlaneEnt = Handle(StepGeom_Plane)::DownCast(aPlanes.Value(i));
+    if (!aPlaneEnt.IsNull()) {
+      Handle(Geom_Plane) aPlane = StepToGeom::MakePlane(aPlaneEnt);
+      if (!aPlane.IsNull()) {
+        TDF_Label aPlaneL = theTool->AddClippingPlane(aPlane->Pln(), aPlaneEnt->Name());
+        theClippingPlanes.Append(aPlaneL);
+        TCollection_AsciiString anEntry;
+        TDF_Tool::Entry(aPlaneL, anEntry);
+        anExpression->AssignCat(new TCollection_HAsciiString(anEntry));
+      }
+    }
+    else {
+      anExpression->AssignCat(buildClippingPlanes(aPlanes.Value(i), theClippingPlanes, theTool));
+    }
+    anExpression->AssignCat(anOperation);
+  }
+  // Insert brace instead of operation after last operand.
+  anExpression->SetValue(anExpression->Length(), ')');
+  return anExpression;
+}
+
+
+//=======================================================================
+//function : ReadViews
+//purpose  :
+//=======================================================================
+Standard_Boolean STEPCAFControl_Reader::ReadViews(const Handle(XSControl_WorkSession)& theWS, Handle(TDocStd_Document)& theDoc) const
+{
+  const Handle(Interface_InterfaceModel) &aModel = theWS->Model();
+  Handle(XCAFDoc_ShapeTool) aSTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
+  Handle(XCAFDoc_DimTolTool) aDGTTool = XCAFDoc_DocumentTool::DimTolTool(theDoc->Main());
+  Handle(XCAFDoc_ViewTool) aViewTool = XCAFDoc_DocumentTool::ViewTool(theDoc->Main());
+  if (aDGTTool.IsNull()) return Standard_False;
+
+  Standard_Integer nb = aModel->NbEntities();
+  for (Standard_Integer i = 1; i <= nb; i++) {
+    Handle(Standard_Transient) anEnt = aModel->Value(i);
+    if (!anEnt->IsKind(STANDARD_TYPE(StepVisual_CameraModelD3)))
+      continue;
+    Handle(XCAFView_Object) anObj = new XCAFView_Object();
+    // Import attributes of view
+    Handle(StepVisual_CameraModelD3) aCameraModel = Handle(StepVisual_CameraModelD3)::DownCast(anEnt);
+    anObj->SetName(aCameraModel->Name());
+    Handle(Geom_Axis2Placement) anAxis = StepToGeom::MakeAxis2Placement(aCameraModel->ViewReferenceSystem());
+    anObj->SetViewDirection(anAxis->Direction());
+    anObj->SetUpDirection(anAxis->Direction() ^ anAxis->XDirection());
+    Handle(StepVisual_ViewVolume) aViewVolume = aCameraModel->PerspectiveOfVolume();
+    XCAFView_ProjectionType aType = XCAFView_ProjectionType_NoCamera;
+    if (aViewVolume->ProjectionType() == StepVisual_copCentral)
+      aType = XCAFView_ProjectionType_Central;
+    else if (aViewVolume->ProjectionType() == StepVisual_copParallel)
+      aType = XCAFView_ProjectionType_Parallel;
+    anObj->SetType(aType);
+    Handle(Geom_CartesianPoint) aPoint = StepToGeom::MakeCartesianPoint(aViewVolume->ProjectionPoint());
+    anObj->SetProjectionPoint(aPoint->Pnt());
+    anObj->SetZoomFactor(aViewVolume->ViewPlaneDistance());
+    anObj->SetWindowHorizontalSize(aViewVolume->ViewWindow()->SizeInX());
+    anObj->SetWindowVerticalSize(aViewVolume->ViewWindow()->SizeInY());
+    if (aViewVolume->FrontPlaneClipping())
+      anObj->SetFrontPlaneDistance(aViewVolume->FrontPlaneDistance());
+    if (aViewVolume->BackPlaneClipping())
+      anObj->SetBackPlaneDistance(aViewVolume->BackPlaneDistance());
+    anObj->SetViewVolumeSidesClipping(aViewVolume->ViewVolumeSidesClipping());
+    // Clipping plane
+    Handle(StepVisual_CameraModelD3MultiClipping) aClippingCameraModel =
+      Handle(StepVisual_CameraModelD3MultiClipping)::DownCast(aCameraModel);
+    TDF_LabelSequence aClippingPlanes;
+    if (!aClippingCameraModel.IsNull()) {
+      Handle(TCollection_HAsciiString) aClippingExpression;
+      Handle(XCAFDoc_ClippingPlaneTool) aClippingPlaneTool = XCAFDoc_DocumentTool::ClippingPlaneTool(theDoc->Main());
+      aClippingExpression = buildClippingPlanes(aClippingCameraModel, aClippingPlanes, aClippingPlaneTool);
+      anObj->SetClippingExpression(aClippingExpression);
+    }
+    // Collect shapes and GDTs
+    TDF_LabelSequence aShapes, aGDTs;
+    Handle(XSControl_TransferReader) aTR = theWS->TransferReader();
+    Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
+    const Interface_Graph& aGraph = aTP->Graph();
+    Handle(StepVisual_DraughtingModel) aDModel;
+    Interface_EntityIterator anIter = aGraph.Sharings(aCameraModel);
+    for (; anIter.More() && aDModel.IsNull(); anIter.Next()) {
+      aDModel = Handle(StepVisual_DraughtingModel)::DownCast(anIter.Value());
+    }
+    if (aDModel.IsNull())
+      return Standard_False;
+
+    anIter = aGraph.Shareds(aDModel);
+    for (; anIter.More(); anIter.Next()) {
+      if (anIter.Value()->IsKind(STANDARD_TYPE(StepRepr_MappedItem))) {
+        Handle(StepRepr_MappedItem) anItem = Handle(StepRepr_MappedItem)::DownCast(anIter.Value());
+        Handle(StepRepr_Representation) aRepr = anItem->MappingSource()->MappedRepresentation();
+        collectViewShapes(theWS, theDoc, aRepr, aShapes);
+      }
+      else if (anIter.Value()->IsKind(STANDARD_TYPE(StepVisual_AnnotationOccurrence)) ||
+        anIter.Value()->IsKind(STANDARD_TYPE(StepVisual_DraughtingCallout))) {
+        Interface_EntityIterator aDMIAIter = aGraph.Sharings(anIter.Value());
+        for (; aDMIAIter.More(); aDMIAIter.Next()) {
+          if (!aDMIAIter.Value()->IsKind(STANDARD_TYPE(StepAP242_DraughtingModelItemAssociation)))
+            continue;
+          Handle(StepAP242_DraughtingModelItemAssociation) aDMIA =
+            Handle(StepAP242_DraughtingModelItemAssociation)::DownCast(aDMIAIter.Value());
+          TDF_Label aGDTL;
+          Standard_Boolean isFind = myGDTMap.Find(aDMIA->Definition().Value(), aGDTL);
+          if (!isFind) {
+            isFind = myGDTMap.Find(anIter.Value(), aGDTL);
+          }
+          if (isFind)
+            aGDTs.Append(aGDTL);
+        }
+      }
+      else if (anIter.Value()->IsKind(STANDARD_TYPE(StepVisual_AnnotationPlane))) {
+        Handle(StepVisual_AnnotationPlane) aPlane = Handle(StepVisual_AnnotationPlane)::DownCast(anIter.Value());
+        for (Standard_Integer i = 1; i <= aPlane->NbElements(); i++) {
+          Interface_EntityIterator aDMIAIter = aGraph.Sharings(anIter.Value());
+          for (; aDMIAIter.More(); aDMIAIter.Next()) {
+            if (!aDMIAIter.Value()->IsKind(STANDARD_TYPE(StepAP242_DraughtingModelItemAssociation)))
+              continue;
+            Handle(StepAP242_DraughtingModelItemAssociation) aDMIA =
+              Handle(StepAP242_DraughtingModelItemAssociation)::DownCast(aDMIAIter.Value());
+            TDF_Label aGDTL;
+            Standard_Boolean isFind = myGDTMap.Find(aDMIA->Definition().Value(), aGDTL);
+            if (isFind)
+              aGDTs.Append(aGDTL);
+          }
+        }
+      }
+    }
+    TDF_Label aViewL = aViewTool->AddView();
+    Handle(XCAFDoc_View) aView = XCAFDoc_View::Set(aViewL);
+    aView->SetObject(anObj);
+    aViewTool->SetView(aShapes, aGDTs, aClippingPlanes, aViewL);
+    aViewTool->Lock(aViewL);
+  }
+  return Standard_True;
+}
+
 //=======================================================================
 //function : SettleShapeData
 //purpose  :
@@ -4474,3 +4719,23 @@ Standard_Boolean STEPCAFControl_Reader::GetMatMode () const
 {
   return myMatMode;
 }
+
+//=======================================================================
+//function : SetViewMode
+//purpose  : 
+//=======================================================================
+
+void STEPCAFControl_Reader::SetViewMode(const Standard_Boolean viewmode)
+{
+  myViewMode = viewmode;
+}
+
+//=======================================================================
+//function : GetViewMode
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean STEPCAFControl_Reader::GetViewMode() const
+{
+  return myViewMode;
+}

src/STEPCAFControl/STEPCAFControl_Reader.hxx

@@ -31,6 +31,8 @@
 #include <STEPCAFControl_DataMapOfPDExternFile.hxx>
 #include <XCAFDoc_DataMapOfShapeLabel.hxx>
 #include <TColStd_HSequenceOfTransient.hxx>
+#include <XCAFDimTolObjects_DatumModifiersSequence.hxx>
+#include <XCAFDimTolObjects_DatumModifWithValue.hxx>
 class XSControl_WorkSession;
 class TDocStd_Document;
 class TCollection_AsciiString;
@@ -44,6 +46,7 @@ class Transfer_TransientProcess;
 class StepShape_ConnectedFaceSet;
 class StepRepr_NextAssemblyUsageOccurrence;
 class STEPConstruct_Tool;
+class StepDimTol_Datum;
 
 
 //! Provides a tool to read STEP file and put it into
@@ -153,6 +156,12 @@ public:
   Standard_EXPORT void SetMatMode (const Standard_Boolean matmode);
   
   Standard_EXPORT Standard_Boolean GetMatMode() const;
+  
+  //! Set View mode
+  Standard_EXPORT void SetViewMode(const Standard_Boolean viewmode);
+
+  //! Get View mode
+  Standard_EXPORT Standard_Boolean GetViewMode() const;
 
 
 
@@ -201,12 +210,15 @@ protected:
   
   //! Reads D&GT for instances defined in the STEP model and
   //! set reference between shape instances from different assemblyes
-  Standard_EXPORT Standard_Boolean ReadGDTs (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc) const;
+  Standard_EXPORT Standard_Boolean ReadGDTs (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc);
   
   //! Reads materials for instances defined in the STEP model and
   //! set reference between shape instances from different assemblyes
   Standard_EXPORT Standard_Boolean ReadMaterials (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const Handle(TColStd_HSequenceOfTransient)& SeqPDS) const;
   
+  //! Reads Views for instances defined in the STEP model
+  Standard_EXPORT Standard_Boolean ReadViews(const Handle(XSControl_WorkSession)& theWS, Handle(TDocStd_Document)& theDoc) const;
+
   //! Populates the sub-Label of the passed TDF Label with shape
   //! data associated with the given STEP Representation Item,
   //! including naming and topological information.
@@ -238,6 +250,26 @@ protected:
 
 private:
 
+  //! Internal method. Import all Datum attributes and set them to XCAF object. Set connection of Datum to GeomTolerance (theGDTL).
+  Standard_Boolean setDatumToXCAF(const Handle(StepDimTol_Datum)& theDat,
+    const TDF_Label theGDTL,
+    const Standard_Integer thePositionCounter,
+    const XCAFDimTolObjects_DatumModifiersSequence& theXCAFModifiers,
+    const XCAFDimTolObjects_DatumModifWithValue theXCAFModifWithVal,
+    const Standard_Real theModifValue,
+    const Handle(TDocStd_Document)& theDoc,
+    const Handle(XSControl_WorkSession)& theWS);
+  
+  //! Internal method. Read Datums, connected to GeomTolerance theGDTL.
+  Standard_Boolean readDatumsAP242(const Handle(Standard_Transient)& theEnt,
+    const TDF_Label theGDTL,
+    const Handle(TDocStd_Document)& theDoc,
+    const Handle(XSControl_WorkSession)& theWS);
+
+  //! Internal method. Read Dimension or GeomTolerance.
+  TDF_Label createGDTObjectInXCAF(const Handle(Standard_Transient)& theEnt,
+    const Handle(TDocStd_Document)& theDoc,
+    const Handle(XSControl_WorkSession)& theWS);
 
 
   STEPControl_Reader myReader;
@@ -249,7 +281,8 @@ private:
   Standard_Boolean mySHUOMode;
   Standard_Boolean myGDTMode;
   Standard_Boolean myMatMode;
-
+  Standard_Boolean myViewMode;
+  NCollection_DataMap<Handle(Standard_Transient), TDF_Label> myGDTMap;
 
 };
 

src/SWDRAW/SWDRAW_ShapeUpgrade.cxx

@@ -41,6 +41,7 @@
 #include <ShapeFix.hxx>
 #include <ShapeFix_ComposeShell.hxx>
 #include <ShapeUpgrade.hxx>
+#include <ShapeUpgrade_CombineToCylinder.hxx>
 #include <ShapeUpgrade_RemoveInternalWires.hxx>
 #include <ShapeUpgrade_RemoveLocations.hxx>
 #include <ShapeUpgrade_ShapeConvertToBezier.hxx>
@@ -1476,6 +1477,69 @@ Standard_Integer reshape(Draw_Interpretor& di,
   return 0;
 }
 
+//=======================================================================
+// CombineToCylinder
+//=======================================================================
+static Standard_Integer CombineToCylinder(Draw_Interpretor& di, Standard_Integer n, const char** a)
+{
+  if (n < 3)
+  {
+    di << "Use combinetocyl result shape [-t val] [-a val]\n";
+    di << "options:\n";
+    di << "-t val to set linear tolerance (default is 1e-7)\n";
+    di << "-a val to set angular tolerance (default is 1e-12)\n";
+    return 1;
+  }
+
+  TopoDS_Shape aShape = DBRep::Get(a[2]);
+  if (aShape.IsNull())
+    return 1;
+
+  // default values
+  Standard_Real aLinTol = Precision::Confusion();
+  Standard_Real aAngTol = Precision::Angular();
+
+  if (n > 3)
+  {
+    for (int i = 3; i < n; i++)
+    {
+      if (!strcmp(a[i], "-t") || !strcmp(a[i], "-a"))
+      {
+        if (++i < n)
+        {
+          if (a[i - 1][1] == 't')
+            aLinTol = Draw::Atof(a[i]);
+          else
+            aAngTol = Draw::Atof(a[i]) * M_PI / 180.;
+        }
+        else
+        {
+          di << "value expected after " << a[i - 1];
+          return 1;
+        }
+      }
+    }
+  }
+
+  ShapeUpgrade_CombineToCylinder aTool;
+  aTool.SetShape(aShape);
+  aTool.SetLinearTolerance(aLinTol);
+  aTool.SetAngularTolerance(aAngTol);
+  aTool.Build();
+  if (!aTool.IsDone())
+  {
+    di << "Not done";
+  }
+  else
+  {
+    di << "Number of new merged faces: " << aTool.NbNewFaces();
+    di << "\nNumber of replaced faces: " << aTool.NbReplacedFaces();
+    const TopoDS_Shape& Result = aTool.Shape();
+    DBRep::Set(a[1], Result);
+  }
+  return 0;
+}
+
 //=======================================================================
 //function : InitCommands
 //purpose  : 
@@ -1589,4 +1653,7 @@ Standard_Integer reshape(Draw_Interpretor& di,
     "\n      '-remove what'         Removes 'what' sub-shape"
     "\n    Requests '-replace' and '-remove' can be repeated many times.",
     __FILE__, reshape, g);
+
+  theCommands.Add("combinetocylinder",
+                  "run w/o arguments to get help", __FILE__, CombineToCylinder, g);
 }

src/Shaders/PhongShading.fs

@@ -166,10 +166,11 @@ vec4 computeLighting (in vec3 theNormal,
   vec4 aMaterialDiffuse  = gl_FrontFacing ? occFrontMaterial_Diffuse()  : occBackMaterial_Diffuse();
   vec4 aMaterialSpecular = gl_FrontFacing ? occFrontMaterial_Specular() : occBackMaterial_Specular();
   vec4 aMaterialEmission = gl_FrontFacing ? occFrontMaterial_Emission() : occBackMaterial_Emission();
-  return vec4 (Ambient,  1.0) * aMaterialAmbient
-       + vec4 (Diffuse,  1.0) * aMaterialDiffuse
-       + vec4 (Specular, 1.0) * aMaterialSpecular
-                              + aMaterialEmission;
+  vec3 aColor = Ambient  * aMaterialAmbient.rgb
+              + Diffuse  * aMaterialDiffuse.rgb
+              + Specular * aMaterialSpecular.rgb
+                         + aMaterialEmission.rgb;
+  return vec4 (aColor, aMaterialDiffuse.a);
 }
 
 //! Entry point to the Fragment Shader
@@ -185,7 +186,14 @@ void main()
     }
   }
 
-  gl_FragColor = computeLighting (normalize (Normal),
+  occFragColor = computeLighting (normalize (Normal),
                                   normalize (View),
                                   Position);
+
+  if (occOitEnableWrite != 0)
+  {
+    float aWeight     = occFragColor.a * clamp (1e+2 * pow (1.0 - gl_FragCoord.z * occOitDepthWeight, 3.0), 1e-2, 1e+2);
+    occFragCoverage.r = occFragColor.a * aWeight;
+    occFragColor      = vec4 (occFragColor.rgb * occFragColor.a * aWeight, occFragColor.a);
+  }
 }

src/Shaders/Shaders_Declarations_glsl.pxx

@@ -50,8 +50,16 @@ static const char Shaders_Declarations_glsl[] =
   "  THE_ATTRIBUTE vec4 occVertColor;\n"
   "#elif (__VERSION__ >= 130)\n"
   "  out vec4 occFragColor;\n"
+  "  #ifdef OCC_enable_draw_buffers\n"
+  "    out vec4 occFragCoverage;\n"
+  "  #endif\n"
   "#else\n"
-  "  #define occFragColor gl_FragColor\n"
+  "  #ifdef OCC_enable_draw_buffers\n"
+  "    #define occFragColor    gl_FragData[0]\n"
+  "    #define occFragCoverage gl_FragData[1]\n"
+  "  #else\n"
+  "    #define occFragColor gl_FragColor\n"
+  "  #endif\n"
   "#endif\n"
   "\n"
   "// Matrix state\n"
@@ -113,6 +121,10 @@ static const char Shaders_Declarations_glsl[] =
   "uniform               vec4      occTexTrsf2d[2];       //!< 2D texture transformation parameters\n"
   "uniform               float     occPointSize;          //!< point size\n"
   "\n"
+  "//! Parameters of blended order-independent transparency rendering algorithm\n"
+  "uniform               int       occOitEnableWrite; //!< Enable bit for writing color (occFragColor), coverage (occFragCoverage) buffers of OIT processing\n"
+  "uniform               float     occOitDepthWeight; //!< Influence of the depth component to the coverage of the accumulated fragment\n"
+  "\n"
   "//! Parameters of clipping planes\n"
   "uniform               vec4 occClipPlaneEquations[THE_MAX_CLIP_PLANES];\n"
   "uniform THE_PREC_ENUM int  occClipPlaneCount;   //!< Total number of clip planes\n";

src/ShapeUpgrade/FILES

@@ -4,6 +4,8 @@ ShapeUpgrade_ClosedEdgeDivide.cxx
 ShapeUpgrade_ClosedEdgeDivide.hxx
 ShapeUpgrade_ClosedFaceDivide.cxx
 ShapeUpgrade_ClosedFaceDivide.hxx
+ShapeUpgrade_CombineToCylinder.cxx
+ShapeUpgrade_CombineToCylinder.hxx
 ShapeUpgrade_ConvertCurve2dToBezier.cxx
 ShapeUpgrade_ConvertCurve2dToBezier.hxx
 ShapeUpgrade_ConvertCurve3dToBezier.cxx

src/ShapeUpgrade/ShapeUpgrade_CombineToCylinder.cxx

@@ -0,0 +1,901 @@
+//-Copyright: Open CASCADE 2016
+// Created on: 2016-08-01
+// Created by: Mikhail Sazonov
+// Copyright (c) 2016 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.
+
+#include <ShapeUpgrade_CombineToCylinder.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepAdaptor_Surface.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepTools.hxx>
+#include <BRepTools_ReShape.hxx>
+#include <ElCLib.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_BSplineCurve.hxx>
+#include <GeomAPI_PointsToBSpline.hxx>
+#include <gce_MakeCirc.hxx>
+#include <gp_Ax1.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Cylinder.hxx>
+#include <gp_Pln.hxx>
+#include <IntAna_IntConicQuad.hxx>
+#include <ShapeAnalysis_Curve.hxx>
+#include <ShapeFix_Shape.hxx>
+#include <TColStd_MapOfInteger.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
+#include <Precision.hxx>
+
+//=======================================================================
+//function : ShapeUpgrade_CombineToCylinder
+//purpose  : 
+//=======================================================================
+ShapeUpgrade_CombineToCylinder::ShapeUpgrade_CombineToCylinder()
+  : myLinTol(Precision::Confusion()),
+    myAngTol(Precision::Angular()),
+    myNbNewFaces(0),
+    myNbReplacedFaces(0),
+    myDone(Standard_False)
+{
+  myContext = new BRepTools_ReShape;
+}
+
+//=======================================================================
+//function : sortEdges
+//purpose  : 
+//=======================================================================
+static void sortEdges(const TopoDS_Shape& theShape,
+                            const TopTools_IndexedDataMapOfShapeListOfShape& theMapEF,
+                            const Standard_Real theLinTol,
+                            const Standard_Real theAngTol,
+                            TopTools_MapOfShape& theStopEdges,
+                            NCollection_DataMap<TopoDS_Shape,gp_Cylinder>& theMapECyl)
+{
+  TopExp_Explorer anEx(theShape, TopAbs_EDGE);
+  for (; anEx.More(); anEx.Next())
+  {
+    const TopoDS_Edge& anEdge = TopoDS::Edge(anEx.Current());
+    const TopTools_ListOfShape* pFaces = theMapEF.Seek(anEdge);
+    if (!pFaces)
+      continue;
+
+    // check for manifold edge
+    if (pFaces->Extent() != 2)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // Get curve of the edge and check if it is a line
+    BRepAdaptor_Curve aCurve(anEdge);
+    if (aCurve.GetType() != GeomAbs_Line)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+    // Check if the edge has enough length
+    Standard_Real aLength = GCPnts_AbscissaPoint::Length(aCurve);
+    if (aLength < 2.*theLinTol)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // check that both faces are planar, if no then add the edge to stop list
+    TopoDS_Face aFaces[2] = { TopoDS::Face(pFaces->First()), TopoDS::Face(pFaces->Last()) };
+    BRepAdaptor_Surface aSurf[2] = {
+      BRepAdaptor_Surface(aFaces[0], Standard_False),
+      BRepAdaptor_Surface(aFaces[1], Standard_False) };
+    if (aSurf[0].GetType() != GeomAbs_Plane || aSurf[1].GetType() != GeomAbs_Plane)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // check if edge is sharp, if yes then add it to stop list
+    gp_Pln aPl1 = aSurf[0].Plane();
+    gp_Pln aPl2 = aSurf[1].Plane();
+    if (aPl1.Axis().Direction().Angle(aPl2.Axis().Direction()) > theAngTol)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // Create plane perpendicular to the edge
+    gp_Lin aLin = aCurve.Line();
+    gp_Pln aPln(aLin.Location(), aLin.Direction());
+
+    // Get opposite edges on each face
+    TopoDS_Edge anOpEdges[2];
+    gp_Lin anOpLines[2];
+    Standard_Integer i;
+    for (i = 0; i < 2; i++)
+    {
+      TopExp_Explorer anEx1(aFaces[i], TopAbs_EDGE);
+      Standard_Integer nbE = 0;
+      for (; anEx1.More(); anEx1.Next(), nbE++)
+      {
+        if (anOpEdges[i].IsNull())
+        {
+          const TopoDS_Edge& aE = TopoDS::Edge(anEx1.Current());
+          if (!aE.IsSame(anEdge))
+          {
+            BRepAdaptor_Curve aC(aE);
+            if (aC.GetType() == GeomAbs_Line)
+            {
+              gp_Lin aL = aC.Line();
+              if (aL.Direction().IsParallel(aLin.Direction(), theAngTol))
+              {
+                anOpEdges[i] = aE;
+                anOpLines[i] = aL;
+              }
+            }
+          }
+        }
+      }
+      if (nbE != 4)
+        break; // face has non-rectangular form
+    }
+    if (anOpEdges[0].IsNull() || anOpEdges[1].IsNull())
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // intersect all 3 edges with the plane
+    gp_Lin aLines[3] = { anOpLines[0], aLin, anOpLines[1] };
+    gp_Pnt anIntPnt[3];
+    for (i = 0; i < 3; i++)
+    {
+      IntAna_IntConicQuad anInter(aLines[i], aPln, theAngTol);
+      if (!anInter.IsDone() || anInter.NbPoints() != 1)
+        break;
+      anIntPnt[i] = anInter.Point(1);
+    }
+    if (i < 3)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // check that distances to points on opposite edges are equal
+    Standard_Real aDist1 = anIntPnt[0].Distance(anIntPnt[1]);
+    Standard_Real aDist2 = anIntPnt[2].Distance(anIntPnt[1]);
+    if (fabs(aDist1 - aDist2) > theLinTol)
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+
+    // compute the circle radius
+    gce_MakeCirc aCircMaker(anIntPnt[0], anIntPnt[1], anIntPnt[2]);
+    if (!aCircMaker.IsDone())
+    {
+      theStopEdges.Add(anEdge);
+      continue;
+    }
+    Standard_Real aRadius = aCircMaker.Value().Radius();
+    const gp_Ax1& aCylAxis = aCircMaker.Value().Axis();
+    gp_Cylinder aCyl(gp_Ax3(aCylAxis.Location(), aCylAxis.Direction()), aRadius);
+    theMapECyl.Bind(anEdge, aCyl);
+  }
+}
+
+//=======================================================================
+//function : updateBoundary
+//purpose  : 
+//=======================================================================
+static void updateBoundary(TopTools_ListOfShape& theBoundary,
+                           const TopoDS_Shape& theFace,
+                           const TopoDS_Shape& theConnectingEdge,
+                           const TopTools_MapOfShape& theStopEdges)
+{
+  // iterate on all edges of the face
+  TopExp_Explorer anEx(theFace, TopAbs_EDGE);
+  for (; anEx.More(); anEx.Next())
+  {
+    const TopoDS_Edge& anEdge = TopoDS::Edge(anEx.Current());
+    if (anEdge.IsSame(theConnectingEdge) || theStopEdges.Contains(anEdge))
+      continue; // skip stop edges
+    // find this edge in the boundary
+    TopTools_ListIteratorOfListOfShape anIt(theBoundary);
+    while (anIt.More())
+    {
+      if (anIt.Value().IsSame(anEdge))
+        break;
+      anIt.Next();
+    }
+    if (anIt.More())
+    {
+      // found, remove it from boundary
+      theBoundary.Remove(anIt);
+    }
+    else
+    {
+      // not found, add to boundary
+      theBoundary.Append(anEdge);
+    }
+  }
+}
+
+//=======================================================================
+//function : Auxiliary structures
+//purpose  : 
+//=======================================================================
+namespace CombineToCylinder
+{
+  struct Area
+  {
+    TopoDS_Compound    Faces;
+    const gp_Cylinder* pCylinder;
+    Standard_Integer   nbFaces;
+
+    Area() : pCylinder(0L), nbFaces(0)
+    {}
+    void Init()
+    {
+      Faces.Nullify();
+      nbFaces = 0;
+      BRep_Builder().MakeCompound(Faces);
+    }
+    void AddFace(const TopoDS_Shape& theFace)
+    {
+      BRep_Builder().Add(Faces, theFace);
+      nbFaces++;
+    }
+  };
+}
+
+//=======================================================================
+//function : EqualCylinders
+//purpose  : 
+//=======================================================================
+inline Standard_Boolean EqualCylinders(const gp_Cylinder& theCyl1,
+                                       const gp_Cylinder& theCyl2,
+                                       const Standard_Real theLinTol,
+                                       const Standard_Real theAngTol)
+{
+  // check radii
+  if (fabs(theCyl1.Radius() - theCyl2.Radius()) > theLinTol)
+    return Standard_False;
+  // check if parallel
+  if (!theCyl1.Axis().Direction().IsParallel(theCyl2.Axis().Direction(), theAngTol))
+    return Standard_False;
+  // check distance between axes
+  gp_XYZ aVecO1O2 = theCyl2.Location().XYZ() - theCyl1.Location().XYZ();
+  Standard_Real aDist1 = aVecO1O2.CrossSquareMagnitude(theCyl2.Axis().Direction().XYZ());
+  Standard_Real aDist2 = aVecO1O2.CrossSquareMagnitude(theCyl1.Axis().Direction().XYZ());
+  Standard_Real aTol = theLinTol * theLinTol;
+  return aDist1 <= aTol && aDist2 < aTol;
+}
+
+//=======================================================================
+//function : collectAreas
+//purpose  : 
+//=======================================================================
+static void collectAreas(const TopoDS_Shape& theShape,
+                         const TopTools_IndexedDataMapOfShapeListOfShape& theMapEF,
+                         const TopTools_MapOfShape& theStopEdges,
+                         const NCollection_DataMap<TopoDS_Shape, gp_Cylinder>& theMapECyl,
+                         const Standard_Real theLinTol,
+                         const Standard_Real theAngTol,
+                         NCollection_List<CombineToCylinder::Area>& theAreas)
+{
+  TopTools_MapOfShape aPassedFaces;
+
+  // Repeat while there are unprocessed faces
+  for (;;)
+  {
+    // get first unprocessed face
+    TopoDS_Shape aCurFace;
+    TopExp_Explorer anEx(theShape, TopAbs_FACE);
+    for (; anEx.More(); anEx.Next())
+    {
+      aCurFace = anEx.Current();
+      if (!aPassedFaces.Contains(aCurFace))
+        break;
+    }
+    if (!anEx.More())
+      break; // all are processed, stop
+
+    // Start area with it
+    CombineToCylinder::Area anArea;
+    anArea.Init();
+    anArea.AddFace(aCurFace);
+    aPassedFaces.Add(aCurFace);
+
+    // Define edges of boundary of area
+    TopTools_ListOfShape aBoundary;
+    updateBoundary(aBoundary, aCurFace, TopoDS_Shape(), theStopEdges);
+
+    // Add all neighbors to the area while there are unprocessed edges of boundary
+    while (!aBoundary.IsEmpty())
+    {
+      TopTools_ListIteratorOfListOfShape anIt(aBoundary);
+      while (anIt.More())
+      {
+        const TopoDS_Shape& anEdge = anIt.Value();
+        const gp_Cylinder* pCyl = theMapECyl.Seek(anEdge);
+        const TopTools_ListOfShape* pFaces = theMapEF.Seek(anEdge);
+        Standard_ASSERT_RAISE(pCyl && pFaces && pFaces->Extent() == 2, "collectAreas");
+        if (!anArea.pCylinder || EqualCylinders(*anArea.pCylinder, *pCyl, theLinTol, theAngTol))
+        {
+          anArea.pCylinder = pCyl;
+          aCurFace = (aPassedFaces.Contains(pFaces->First()) ? pFaces->Last() : pFaces->First());
+          if (!aPassedFaces.Contains(aCurFace))
+          {
+            // Update boundary adding the next face
+            updateBoundary(aBoundary, aCurFace, anEdge, theStopEdges);
+            anArea.AddFace(aCurFace);
+            aPassedFaces.Add(aCurFace);
+          }
+        }
+        aBoundary.Remove(anIt);
+      }
+    }
+
+    // check if area is well formed
+    if (anArea.pCylinder && anArea.nbFaces > 2)
+    {
+      // Add area to the result list
+      theAreas.Append(anArea);
+    }
+  }
+}
+
+//=======================================================================
+//function : getNextEdge
+//purpose  : 
+//=======================================================================
+static Standard_Boolean getNextEdge(const TopTools_ListOfShape& theChain,
+                                    const Standard_Boolean theFwd,
+                                    const TopTools_IndexedDataMapOfShapeListOfShape& theMapVE,
+                                    const Standard_Real theSmoothAng,
+                                    TopoDS_Edge& theNextEdge)
+{
+  // Get end edge and vertex
+  TopoDS_Edge anEndE, anOppoEdge;
+  TopoDS_Vertex anEndV;
+  if (theFwd)
+  {
+    anEndE = TopoDS::Edge(theChain.Last());
+    anOppoEdge = TopoDS::Edge(theChain.First());
+    anEndV = TopExp::LastVertex(anEndE, Standard_True);
+  }
+  else
+  {
+    anEndE = TopoDS::Edge(theChain.First());
+    anOppoEdge = TopoDS::Edge(theChain.Last());
+    anEndV = TopExp::FirstVertex(anEndE, Standard_True);
+  }
+
+  // Get next edge using topology map; reject the case of multi-connected vertex,
+  // when there are more than one candidate edge
+  const TopTools_ListOfShape& aConnEdges = theMapVE.FindFromKey(anEndV);
+  // Note! aConnEdges can contain duplicates
+  theNextEdge.Nullify();
+  TopTools_ListIteratorOfListOfShape itL(aConnEdges);
+  for (; itL.More(); itL.Next())
+  {
+    const TopoDS_Shape& aE = itL.Value();
+    if (aE.IsSame(anEndE))
+      continue;
+    if (theNextEdge.IsNull())
+      theNextEdge = TopoDS::Edge(aE);
+    else if(!aE.IsSame(theNextEdge))
+      return Standard_False; // multi-connected vertex
+  }
+
+  // check for closed chain
+  if (theNextEdge.IsSame(anOppoEdge))
+    return Standard_False;
+
+  // Orient the next edge
+  TopoDS_Vertex aNextEndV = (theFwd ? TopExp::FirstVertex(theNextEdge, Standard_True) :
+    TopExp::LastVertex(theNextEdge, Standard_True));
+  if (!aNextEndV.IsSame(anEndV))
+    theNextEdge.Reverse();
+
+  if (theSmoothAng > 0.)
+  {
+    // Check that the edge is linear
+    BRepAdaptor_Curve aNextC(theNextEdge);
+    if (aNextC.GetType() != GeomAbs_Line)
+      return Standard_False;
+
+    // Verify smoothness of connection
+    BRepAdaptor_Curve anEndC(anEndE);
+    gp_Lin anEndLin = anEndC.Line();
+    gp_Lin aNextLin = aNextC.Line();
+    const gp_Dir& anEndDir = anEndLin.Direction();
+    const gp_Dir& aNextDir = aNextLin.Direction();
+    if (!anEndDir.IsParallel(aNextDir, theSmoothAng))
+      return Standard_False;
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : makeEdgesChain
+//purpose  : 
+//=======================================================================
+static void makeEdgesChain(TopTools_ListOfShape& theChain,
+                           const TopTools_IndexedDataMapOfShapeListOfShape& theMapVE,
+                           const Standard_Real theSmoothAng)
+{
+  // Cycle for both ends of the chain
+  Standard_Boolean isFwd[2] = { Standard_True, Standard_False };
+  for (Standard_Integer i = 0; i < 2; i++)
+  {
+    TopoDS_Edge aNextEdge;
+    while (getNextEdge(theChain, isFwd[i], theMapVE, theSmoothAng, aNextEdge))
+    {
+      // add next edge to the chain
+      if (isFwd[i])
+        theChain.Append(aNextEdge);
+      else
+        theChain.Prepend(aNextEdge);
+    }
+  }
+}
+
+//=======================================================================
+//function : createCylFaceFromArea
+//purpose  : 
+//=======================================================================
+static TopoDS_Face createCylFaceFromArea(const TopoDS_Compound& theFaces,
+                                         const gp_Cylinder& theCylinder)
+{
+  // Find boundary edges of the area
+  TopTools_IndexedDataMapOfShapeListOfShape aMapEF, aMapVE;
+  TopExp::MapShapesAndAncestors(theFaces, TopAbs_EDGE, TopAbs_FACE, aMapEF);
+  TopTools_ListOfShape aBoundary;
+  Standard_Integer i;
+  for (i = 1; i <= aMapEF.Extent(); i++)
+  {
+    if (aMapEF(i).Extent() == 1)
+    {
+      const TopoDS_Shape& aE = aMapEF.FindKey(i);
+      aBoundary.Append(aE);
+      TopExp::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMapVE);
+    }
+  }
+
+  // Check the case of closed cylinder. In this case there will be two 
+  // distinct chains of boundary edges, and we need to create a seam edge
+  TopoDS_Edge aSeamEdge;
+  TopTools_ListOfShape aChain;
+  aChain.Append(aBoundary.First());
+  makeEdgesChain(aChain, aMapVE, 0.);
+  TopTools_MapOfShape aMapChain;
+  TopTools_ListIteratorOfListOfShape itC(aChain);
+  for (; itC.More(); itC.Next())
+    aMapChain.Add(itC.Value());
+  TopTools_ListIteratorOfListOfShape itB(aBoundary);
+  for (; itB.More(); itB.Next())
+  {
+    if (!aMapChain.Contains(itB.Value()))
+      break;
+  }
+  if (itB.More())
+  {
+    // It is the case.
+    // Get any multi-connected edge and use it as a seam
+    for (i = 1; i <= aMapEF.Extent(); i++)
+      if (aMapEF(i).Extent() == 2)
+        aSeamEdge = TopoDS::Edge(aMapEF.FindKey(i));
+  }
+
+  // Build new cylindrical face
+  TopoDS_Wire aWire;
+  BRep_Builder().MakeWire(aWire);
+  for (itB.Init(aBoundary); itB.More(); itB.Next())
+  {
+    BRep_Builder().Add(aWire, itB.Value());
+  }
+  if (!aSeamEdge.IsNull())
+  {
+    BRep_Builder().Add(aWire, aSeamEdge);
+    BRep_Builder().Add(aWire, aSeamEdge.Reversed());
+  }
+  TopoDS_Face aCylFace = BRepBuilderAPI_MakeFace(theCylinder, aWire);
+
+  // Check orientation of an initial face, so that possibly to reverse the new face.
+  // The new cylindrical surface always has normal directed outside of cylinder.
+  // If an initial face has normal (taking face orientation into account) directed 
+  // inside then we must reverse the new face.
+  const TopoDS_Edge& aE = TopoDS::Edge(aBoundary.First());
+  const TopoDS_Face& aF = TopoDS::Face(aMapEF.FindFromKey(aE).First());
+  BRepAdaptor_Surface aSurf(aF, Standard_False);
+  Standard_Real aParF, aParL;
+  Handle(Geom2d_Curve) aPCurve = BRep_Tool::CurveOnSurface(aE, aF, aParF, aParL);
+  Standard_ASSERT_RAISE(!aPCurve.IsNull(), "createCylFaceFromArea");
+  gp_Pnt2d aP2d = aPCurve->Value(aParF);
+  gp_Pnt aP;
+  gp_Vec aDU, aDV;
+  aSurf.D1(aP2d.X(), aP2d.Y(), aP, aDU, aDV);
+  gp_XYZ aN = aDU.XYZ() ^ aDV.XYZ();
+  if (aF.Orientation() == TopAbs_REVERSED)
+    aN.Reverse();
+  gp_XYZ aVecFromAxis = aP.XYZ() - theCylinder.Location().XYZ();
+  if (aVecFromAxis * aN < 0.)
+  {
+    // need reverse
+    aCylFace.Reverse();
+  }
+  return aCylFace;
+}
+
+//=======================================================================
+//function : updateVertexOnCirc
+//purpose  : 
+//=======================================================================
+static Standard_Boolean updateVertexOnCirc(const TopoDS_Vertex& theV,
+                                           const gp_Circ& theCirc,
+                                           Standard_Real theMaxDist,
+                                           Standard_Real& thePar)
+{
+  Standard_Real aTol = BRep_Tool::Tolerance(theV);
+  gp_Pnt aP = BRep_Tool::Pnt(theV);
+  thePar = ElCLib::Parameter(theCirc, aP);
+  gp_Pnt aProj = ElCLib::Value(thePar, theCirc);
+  Standard_Real aDist = aProj.SquareDistance(aP);
+  Standard_Boolean isOK = Standard_False;
+  if (aDist > aTol*aTol)
+  {
+    if (aDist < theMaxDist*theMaxDist)
+    {
+      BRep_Builder().UpdateVertex(theV, sqrt(aDist)*1.001);
+      isOK = Standard_True;
+    }
+  }
+  return isOK;
+}
+
+//=======================================================================
+//function : createCurveEdge
+//purpose  : 
+//=======================================================================
+static TopoDS_Edge createCurveEdge(const TopTools_ListOfShape& theChain,
+                                   const TopTools_IndexedDataMapOfShapeListOfShape& theMapEF,
+                                   const Standard_Real theLinTol)
+{
+  // Find a cylindrical face common for all edges
+  TopTools_ListOfShape aCylFaces;
+  TopTools_ListIteratorOfListOfShape itL(theChain);
+  for (; itL.More(); itL.Next())
+  {
+    const TopoDS_Shape& aE = itL.Value();
+    const TopTools_ListOfShape& aFaces = theMapEF.FindFromKey(aE);
+    // get cyl faces of the current edge
+    TopTools_ListOfShape aCurCylFaces;
+    TopTools_ListIteratorOfListOfShape itF(aFaces);
+    for (; itF.More(); itF.Next())
+    {
+      const TopoDS_Face& aF = TopoDS::Face(itF.Value());
+      BRepAdaptor_Surface aSurf(aF, Standard_False);
+      if (aSurf.GetType() == GeomAbs_Cylinder)
+        aCurCylFaces.Append(aF);
+    }
+
+    if (aCylFaces.IsEmpty())
+      // initialize cyl faces with the first edge
+      aCylFaces.Append(aCurCylFaces);
+    else
+    {
+      // filter cyl faces leaving only common ones
+      TopTools_ListIteratorOfListOfShape itCF(aCylFaces);
+      while (itCF.More())
+      {
+        const TopoDS_Shape& aF = itCF.Value();
+        TopTools_ListIteratorOfListOfShape itCF1(aCurCylFaces);
+        for (; itCF1.More(); itCF1.Next())
+          if (itCF1.Value().IsSame(aF))
+            break;
+        if (!itCF1.More())
+          aCylFaces.Remove(itCF);
+        else
+          itCF.Next();
+      }
+    }
+    if (aCylFaces.IsEmpty())
+      return TopoDS_Edge(); // no common cyl faces
+  }
+  if (aCylFaces.IsEmpty())
+    return TopoDS_Edge();
+  const TopoDS_Face& aCylFace = TopoDS::Face(aCylFaces.First());
+  BRepAdaptor_Surface aCylSurf(aCylFace, Standard_False);
+  gp_Cylinder aCyl = aCylSurf.Cylinder();
+  const gp_Dir& aCylDir = aCyl.Axis().Direction();
+  const gp_Pnt& aCylLoc = aCyl.Location();
+  const Standard_Real aRadius = aCyl.Radius();
+
+  // Check if the chain is closed
+  TopoDS_Vertex aVF, aVL;
+  aVF = TopoDS::Vertex(TopExp::FirstVertex(TopoDS::Edge(theChain.First()), Standard_True));
+  aVL = TopoDS::Vertex(TopExp::LastVertex(TopoDS::Edge(theChain.Last()), Standard_True));
+  Standard_Boolean isClosed = aVF.IsSame(aVL);
+
+  // Check if all points are in plane perpendicular to the cylinder axis;
+  // in such case the curve is a circle
+  TColgp_Array1OfPnt aPnts(1, theChain.Extent()+1);
+  Standard_Real aTol = 0.;
+  Standard_Integer i = 1;
+  for (itL.Init(theChain); itL.More(); itL.Next(), i++)
+  {
+    const TopoDS_Edge& aE = TopoDS::Edge(itL.Value());
+    TopoDS_Shape aV = TopExp::FirstVertex(aE, Standard_True);
+    aPnts(i) = BRep_Tool::Pnt(TopoDS::Vertex(aV));
+    aTol = Max(aTol, BRep_Tool::Tolerance(aE));
+  }
+  aPnts(i) = BRep_Tool::Pnt(aVL);
+  gp_XYZ aMidPnt(0, 0, 0);
+  for (i = 1; i <= aPnts.Length(); i++)
+    aMidPnt += aPnts(i).XYZ();
+  aMidPnt /= aPnts.Length();
+  aTol = Min(aTol, theLinTol);
+  for (i = 1; i <= aPnts.Length(); i++)
+  {
+    Standard_Real aDist = fabs((aPnts(i).XYZ() - aMidPnt) * aCylDir.XYZ());
+    if (aDist > aTol)
+      break;
+  }
+  Standard_Boolean isCircle = (i > aPnts.Length());
+
+  // Create new edge
+  TopoDS_Edge aNewEdge;
+  if (isCircle)
+  {
+    // Create circular edge.
+    // Find center by projecting aMidPnt to the cylinder axis
+    gp_XYZ aVecOM = aMidPnt - aCylLoc.XYZ();
+    gp_Pnt aCenter = aCylLoc.Translated(aCylDir.XYZ() * (aVecOM * aCylDir.XYZ()));
+    gp_XYZ aXDir = aPnts(1).XYZ() - aCenter.XYZ();
+    gp_XYZ aCircDir = aCylDir.XYZ();
+    gp_XYZ aTanDir = aPnts(2).XYZ() - aPnts(1).XYZ();
+    if ((aXDir ^ aTanDir)* aCylDir.XYZ() < 0.)
+      aCircDir.Reverse();
+    gp_Circ aCirc(gp_Ax2(aCenter, aCircDir, aXDir), aRadius);
+    Handle(Geom_Circle) aCurve = new Geom_Circle(aCirc);
+    // update vertices tolerance, but not more than on a value aTol,
+    // otherwise skip building a circle, and build bspline.
+    Standard_Real aPar;
+    if (updateVertexOnCirc(aVF, aCirc, aTol, aPar))
+    {
+      if (isClosed)
+      {
+        // full circle
+        aNewEdge = BRepBuilderAPI_MakeEdge(aCurve, aVF, aVL, 0, M_PI*2.);
+      }
+      else
+      {
+        // an arc
+        if (updateVertexOnCirc(aVL, aCirc, aTol, aPar))
+          aNewEdge = BRepBuilderAPI_MakeEdge(aCurve, aVF, aVL, 0., aPar);
+      }
+    }
+  }
+  if (aNewEdge.IsNull())
+  {
+    // not a circle, try building bspline
+    gp_Pnt aPnts1[3];
+    const gp_Pnt* pPnts = &aPnts(1);
+    Standard_Integer np = aPnts.Length();
+    if (np == 2)
+    {
+      gp_XYZ anEdgeDir = aPnts(2).XYZ() - aPnts(1).XYZ();
+      const Standard_Real anEpsAng = 1e-4;
+      if (aCylDir.IsParallel(anEdgeDir, anEpsAng))
+        return aNewEdge;
+      // we have only two points; create additional point in the middle of the segment
+      aPnts1[0] = aPnts(1);
+      aPnts1[2] = aPnts(2);
+      aPnts1[1] = (aPnts1[0].XYZ() + aPnts1[2].XYZ()) * 0.5;
+      pPnts = aPnts1;
+      np = 3;
+    }
+    TColgp_Array1OfPnt aPntA(*pPnts, 1, np);
+    // Create b-spline curve
+    Standard_Integer aDegMin = 3;
+    Standard_Integer aDegMax = 3;
+    GeomAbs_Shape aCont = GeomAbs_C2;
+    GeomAPI_PointsToBSpline aCreator(aPntA, aDegMin, aDegMax, aCont, aTol);
+    if (aCreator.IsDone())
+    {
+      const Handle(Geom_BSplineCurve)& aCurve = aCreator.Curve();
+      Standard_Real aTol = BRep_Tool::Tolerance(aVF);
+      Standard_Real aParF = aCurve->FirstParameter();
+      Standard_Real aParL = aCurve->LastParameter();
+      Standard_Real aDist = aCurve->Value(aParF).SquareDistance(aPntA(1));
+      if (aDist > aTol*aTol)
+        BRep_Builder().UpdateVertex(aVF, sqrt(aDist));
+      if (!isClosed)
+      {
+        aTol = BRep_Tool::Tolerance(aVL);
+        aDist = aCurve->Value(aParL).SquareDistance(aPntA(np));
+        if (aDist > aTol*aTol)
+          BRep_Builder().UpdateVertex(aVL, sqrt(aDist));
+      }
+      aNewEdge = BRepBuilderAPI_MakeEdge(aCurve, aVF, aVL, aParF, aParL);
+    }
+  }
+  return aNewEdge;
+}
+
+//=======================================================================
+//function : mergeEdges
+//purpose  : 
+//=======================================================================
+static void mergeEdges(const TopoDS_Shape& theShape,
+                       const Standard_Real theLinTol,
+                       const Standard_Real theAngTol,
+                       const Handle(BRepTools_ReShape)& theContext)
+{
+  // Create topological data maps
+  TopTools_IndexedDataMapOfShapeListOfShape aMapVE, aMapEF;
+  TopExp::MapShapesAndAncestors(theShape, TopAbs_VERTEX, TopAbs_EDGE, aMapVE);
+  TopExp::MapShapesAndAncestors(theShape, TopAbs_EDGE, TopAbs_FACE, aMapEF);
+
+  // The idea is to gather chains of edges in which all intermediate vertices
+  // have only two neighboring edges, and do not have connection to any other edges
+  // from the shape.
+
+  // Prepare set of all edges
+  TopTools_IndexedMapOfShape anEdges;
+  TopExp::MapShapes(theShape, TopAbs_EDGE, anEdges);
+  TColStd_MapOfInteger anEdgesInd;  // set of indices of left edges
+  Standard_Integer i;
+  for (i = 1; i <= anEdges.Extent(); i++)
+    anEdgesInd.Add(i);
+
+  // Process while there are unprocessed edges
+  while (!anEdgesInd.IsEmpty())
+  {
+    // Get an unprocessed edge
+    Standard_Integer aEInd = TColStd_MapIteratorOfMapOfInteger(anEdgesInd).Value();
+    anEdgesInd.Remove(aEInd);
+    TopoDS_Edge aFirstEdge = TopoDS::Edge(anEdges(aEInd));
+    BRepAdaptor_Curve aCurve(aFirstEdge);
+    if (aCurve.GetType() != GeomAbs_Line)
+      continue; // only linear edges are to be merged
+
+    // Start a new chain
+    TopTools_ListOfShape aChain;
+    aChain.Append(aFirstEdge.Oriented(TopAbs_FORWARD));
+    makeEdgesChain(aChain, aMapVE, theAngTol);
+
+    // Remove it from the left edges
+    TopTools_ListIteratorOfListOfShape itL(aChain);
+    for (; itL.More(); itL.Next())
+    {
+      const TopoDS_Shape& aE = itL.Value();
+      Standard_Integer aEI = anEdges.FindIndex(aE);
+      anEdgesInd.Remove(aEI);
+    }
+
+    if (aChain.Extent() > 0)
+    {
+      // Create a new curvilinear edge from the polyline
+      TopoDS_Edge aNewEdge = createCurveEdge(aChain, aMapEF, theLinTol);
+      if (!aNewEdge.IsNull())
+      {
+        aNewEdge.Orientation(aFirstEdge.Orientation());
+        // Replace edges from the chain with the new edge.
+        Standard_Integer nbMerged = 0;
+        for (itL.Init(aChain); itL.More(); itL.Next(), nbMerged++)
+        {
+          const TopoDS_Shape& aE = itL.Value();
+          if (nbMerged == 0)
+            theContext->Replace(aE, aNewEdge);
+          else
+            theContext->Remove(aE);
+        }
+      }
+    }
+  }
+}
+
+//=======================================================================
+//function : Build
+//purpose  : 
+//=======================================================================
+void ShapeUpgrade_CombineToCylinder::Build()
+{
+  myDone = Standard_False;
+  myNbNewFaces = myNbReplacedFaces = 0;
+  myShape.Nullify();
+
+  TopTools_IndexedDataMapOfShapeListOfShape aMapEF;
+  TopExp::MapShapesAndAncestors(myInitShape, TopAbs_EDGE, TopAbs_FACE, aMapEF);
+
+  // Sort edges in the shape on two groups - stop edges and smooth edges that are 
+  // to be located on a cylinder wall parallel to its axis.
+  TopTools_MapOfShape aStopEdges;
+  NCollection_DataMap<TopoDS_Shape, gp_Cylinder> aMapECyl;
+  sortEdges(myInitShape, aMapEF, myLinTol, myAngTol, aStopEdges, aMapECyl);
+
+#ifdef DEBUG_CombineToCylinder_StopEdges
+  TopoDS_Compound aCompE;
+  BRep_Builder().MakeCompound(aCompE);
+  TopTools_MapIteratorOfMapOfShape aMapIt(aStopEdges);
+  for (; aMapIt.More(); aMapIt.Next())
+    BRep_Builder().Add(aCompE, aMapIt.Value());
+  BRepTools::Write(aCompE, "stope.brep");
+#endif
+
+  // Collect faces forming same-cylinder areas
+  NCollection_List<CombineToCylinder::Area> anAreas;
+  collectAreas(myInitShape, aMapEF, aStopEdges, aMapECyl, myLinTol, myAngTol, anAreas);
+
+#ifdef DEBUG_CombineToCylinder_Areas
+  TopoDS_Compound aComp;
+  BRep_Builder().MakeCompound(aComp);
+  TopTools_ListIteratorOfListOfShape anItA(anAreas);
+  for (; anItA.More(); anItA.Next())
+    BRep_Builder().Add(aComp, anItA.Value());
+  BRepTools::Write(aComp, "areas.brep");
+#endif
+
+  // Process each area
+  NCollection_List<CombineToCylinder::Area>::Iterator anItAreas(anAreas);
+  for (; anItAreas.More(); anItAreas.Next())
+  {
+    const CombineToCylinder::Area& anArea = anItAreas.Value();
+    if (!anArea.pCylinder)
+      continue;
+
+    TopoDS_Shape aCylFace = createCylFaceFromArea(anArea.Faces, *anArea.pCylinder);
+
+    // Replace faces from the list with the new face.
+    TopExp_Explorer anEx(anArea.Faces, TopAbs_FACE);
+    Standard_Integer nbMerged = 0;
+    for (; anEx.More(); anEx.Next(), nbMerged++)
+    {
+      const TopoDS_Shape& aFace = anEx.Current();
+      if (nbMerged == 0)
+        myContext->Replace(aFace, aCylFace);
+      else
+        myContext->Remove(aFace);
+    }
+    myNbNewFaces++;
+    myNbReplacedFaces += nbMerged;
+  }
+
+  // Build intermediate result shape using replacement context.
+  // This shape will contain chains of linear edges along cylinders
+  // instead of circles or whatever curves.
+  // The next step is to merge them.
+  TopoDS_Shape aTempShape = myContext->Apply(myInitShape);
+  mergeEdges(aTempShape, myLinTol, myAngTol, myContext);
+
+  // Rebuild the result shape using replacement context.
+  myShape = myContext->Apply(myInitShape);
+
+  // build pcurves
+  ShapeFix_Shape aFix(myShape);
+  aFix.Perform();
+  myShape = aFix.Shape();
+  myDone = Standard_True;
+}

src/ShapeUpgrade/ShapeUpgrade_CombineToCylinder.hxx

@@ -0,0 +1,93 @@
+//-Copyright: Open CASCADE 2016
+// Created on: 2016-08-01
+// Created by: Mikhail Sazonov
+// Copyright (c) 2016 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 _ShapeUpgrade_CombineToCylinder_HeaderFile
+#define _ShapeUpgrade_CombineToCylinder_HeaderFile
+
+#include <Standard_TypeDef.hxx>
+#include <TopoDS_Shape.hxx>
+
+class BRepTools_ReShape;
+
+//! This tool tries to merge planar faces constituting a cylindrical surface into one face.
+//! The algorithm checks that all merged faces have smooth change of normal within the given
+//! angular tolerance.
+class ShapeUpgrade_CombineToCylinder
+{
+public:
+  
+  //! empty constructor
+  Standard_EXPORT ShapeUpgrade_CombineToCylinder();
+  
+  //! Sets input shape
+  void SetShape(const TopoDS_Shape& theShape)
+  {
+    myInitShape = theShape;
+  }
+  
+  //! Sets the linear tolerance. Default value is Precision::Confusion().
+  void SetLinearTolerance(const Standard_Real theValue)
+  {
+    myLinTol = theValue;
+  }
+
+  //! Sets the angular tolerance. Default value is Precision::Angular().
+  void SetAngularTolerance(const Standard_Real theValue)
+  {
+    myAngTol = theValue;
+  }
+
+  //! Builds the resulting shape
+  Standard_EXPORT void Build();
+  
+  //! Returns true if the result shape was successfully built.
+  Standard_Boolean IsDone() const
+  {
+    return myDone;
+  }
+
+  //! Returns the result shape.
+  const TopoDS_Shape& Shape() const
+  {
+    return myShape;
+  }
+
+  //! Returns the number of new faces built by merging
+  Standard_Integer NbNewFaces() const
+  {
+    return myNbNewFaces;
+  }
+
+  //! Returns the number of replaced faces
+  Standard_Integer NbReplacedFaces() const
+  {
+    return myNbReplacedFaces;
+  }
+
+private:
+
+  TopoDS_Shape myInitShape;
+  Standard_Real myLinTol;
+  Standard_Real myAngTol;
+  TopoDS_Shape myShape;
+  Handle(BRepTools_ReShape) myContext;
+  Standard_Integer myNbNewFaces;
+  Standard_Integer myNbReplacedFaces;
+  Standard_Boolean myDone;
+
+};
+
+#endif // _ShapeUpgrade_CombineToCylinder_HeaderFile

src/StepAP214/StepAP214_Protocol.cxx

@@ -745,6 +745,10 @@ static Standard_CString schemaAP242DIS = "AP242_MANAGED_MODEL_BASED_3D_ENGINEERI
 #include <StepVisual_CharacterizedObjectAndCharacterizedRepresentationAndDraughtingModelAndRepresentation.hxx>
 #include <StepVisual_AnnotationFillArea.hxx>
 #include <StepVisual_AnnotationFillAreaOccurrence.hxx>
+#include <StepVisual_CameraModelD3MultiClipping.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
 
 static int init = 0;
 static Interface_DataMapOfTransientInteger types(800);
@@ -1448,6 +1452,10 @@ StepAP214_Protocol::StepAP214_Protocol ()
   types.Bind (STANDARD_TYPE(StepRepr_ConstructiveGeometryRepresentationRelationship), 713);
   types.Bind (STANDARD_TYPE(StepRepr_CharacterizedRepresentation), 714);
   types.Bind (STANDARD_TYPE(StepVisual_CharacterizedObjectAndCharacterizedRepresentationAndDraughtingModelAndRepresentation), 715);
+  types.Bind (STANDARD_TYPE(StepVisual_CameraModelD3MultiClipping), 716);
+  types.Bind (STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingIntersection), 717);
+  types.Bind (STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingUnion), 718);
+  types.Bind (STANDARD_TYPE(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem), 719);
 }
 
 

src/StepVisual/FILES

@@ -1,5 +1,7 @@
 StepVisual_AnnotationCurveOccurrence.cxx
 StepVisual_AnnotationCurveOccurrence.hxx
+StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.cxx
+StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx
 StepVisual_AnnotationFillArea.cxx
 StepVisual_AnnotationFillArea.hxx
 StepVisual_AnnotationFillAreaOccurrence.cxx
@@ -20,6 +22,8 @@ StepVisual_AreaOrView.cxx
 StepVisual_AreaOrView.hxx
 StepVisual_Array1OfAnnotationPlaneElement.hxx
 StepVisual_Array1OfBoxCharacteristicSelect.hxx
+StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect.hxx
+StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect.hxx
 StepVisual_Array1OfCurveStyleFontPattern.hxx
 StepVisual_Array1OfDirectionCountSelect.hxx
 StepVisual_Array1OfDraughtingCalloutElement.hxx
@@ -47,6 +51,16 @@ StepVisual_CameraModelD2.cxx
 StepVisual_CameraModelD2.hxx
 StepVisual_CameraModelD3.cxx
 StepVisual_CameraModelD3.hxx
+StepVisual_CameraModelD3MultiClipping.cxx
+StepVisual_CameraModelD3MultiClipping.hxx
+StepVisual_CameraModelD3MultiClippingInterectionSelect.cxx
+StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx
+StepVisual_CameraModelD3MultiClippingIntersection.cxx
+StepVisual_CameraModelD3MultiClippingIntersection.hxx
+StepVisual_CameraModelD3MultiClippingUnion.cxx
+StepVisual_CameraModelD3MultiClippingUnion.hxx
+StepVisual_CameraModelD3MultiClippingUnionSelect.cxx
+StepVisual_CameraModelD3MultiClippingUnionSelect.hxx
 StepVisual_CameraUsage.cxx
 StepVisual_CameraUsage.hxx
 StepVisual_CentralOrParallel.hxx
@@ -102,6 +116,8 @@ StepVisual_FontSelect.cxx
 StepVisual_FontSelect.hxx
 StepVisual_HArray1OfAnnotationPlaneElement.hxx
 StepVisual_HArray1OfBoxCharacteristicSelect.hxx
+StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx
+StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx
 StepVisual_HArray1OfCurveStyleFontPattern.hxx
 StepVisual_HArray1OfDirectionCountSelect.hxx
 StepVisual_HArray1OfDraughtingCalloutElement.hxx

src/StepVisual/StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.cxx

@@ -0,0 +1,24 @@
+// Created on: 2017-02-06
+// Created by: Irina KRYLOVA
+// Copyright (c) 2017 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.
+
+#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, StepVisual_AnnotationCurveOccurrence)
+
+//=======================================================================
+//function : StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem
+//purpose  : 
+//=======================================================================
+StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem::StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem()    {  }

src/StepVisual/StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx

@@ -0,0 +1,38 @@
+// Created on: 2017-02-06
+// Created by: Irina KRYLOVA
+// Copyright (c) 2017 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 _StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem_HeaderFile
+#define _StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepVisual_AnnotationCurveOccurrence.hxx>
+
+class StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem;
+DEFINE_STANDARD_HANDLE(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, StepVisual_AnnotationCurveOccurrence)
+//! Added for Dimensional Tolerances
+//! Complex STEP entity AnnotationCurveOccurrence & AnnotationOccurrence & GeometricRepresentationItem & RepresentationItem & StyledItem
+class StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem : public StepVisual_AnnotationCurveOccurrence
+{
+
+public:
+  
+  Standard_EXPORT StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem();
+
+  DEFINE_STANDARD_RTTIEXT(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, StepVisual_AnnotationCurveOccurrence)
+
+};
+#endif // _StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem_HeaderFile

src/StepVisual/StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect.hxx

@@ -0,0 +1,23 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect_HeaderFile
+#define _StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect_HeaderFile
+
+#include <StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepVisual_CameraModelD3MultiClippingInterectionSelect> StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect;
+#endif // _StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect_HeaderFile

src/StepVisual/StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect.hxx

@@ -0,0 +1,23 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect_HeaderFile
+#define _StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect_HeaderFile
+
+#include <StepVisual_CameraModelD3MultiClippingUnionSelect.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepVisual_CameraModelD3MultiClippingUnionSelect> StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect;
+#endif // _StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect_HeaderFile

src/StepVisual/StepVisual_CameraModelD3MultiClipping.cxx

@@ -0,0 +1,45 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
+#include <StepVisual_CameraModelD3MultiClipping.hxx>
+#include <StepVisual_ViewVolume.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CameraModelD3MultiClipping, StepVisual_CameraModelD3)
+
+//=======================================================================
+//function : StepVisual_CameraModelD3MultiClipping
+//purpose  : 
+//=======================================================================
+StepVisual_CameraModelD3MultiClipping::StepVisual_CameraModelD3MultiClipping()  {}
+
+//=======================================================================
+//function : Init
+//purpose  : 
+//=======================================================================
+void StepVisual_CameraModelD3MultiClipping::Init(
+  const Handle(TCollection_HAsciiString)& theName,
+  const Handle(StepGeom_Axis2Placement3d)& theViewReferenceSystem,
+  const Handle(StepVisual_ViewVolume)& thePerspectiveOfVolume,
+  const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect)& theShapeClipping)
+{
+  // Own field
+  myShapeClipping = theShapeClipping;
+  // Inherited fields
+  StepVisual_CameraModelD3::Init(theName, theViewReferenceSystem, thePerspectiveOfVolume);
+}

src/StepVisual/StepVisual_CameraModelD3MultiClipping.hxx

@@ -0,0 +1,59 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_CameraModelD3MultiClipping_HeaderFile
+#define _StepVisual_CameraModelD3MultiClipping_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepVisual_CameraModelD3.hxx>
+class StepGeom_Axis2Placement3d;
+class StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect;
+class StepVisual_ViewVolume;
+class TCollection_HAsciiString;
+
+class StepVisual_CameraModelD3;
+DEFINE_STANDARD_HANDLE(StepVisual_CameraModelD3MultiClipping, StepVisual_CameraModelD3)
+
+class StepVisual_CameraModelD3MultiClipping : public StepVisual_CameraModelD3
+{
+public:
+
+  
+  //! Returns a CameraModelD3MultiClipping
+  Standard_EXPORT StepVisual_CameraModelD3MultiClipping();
+  
+  Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+                             const Handle(StepGeom_Axis2Placement3d)& theViewReferenceSystem,
+                             const Handle(StepVisual_ViewVolume)& thePerspectiveOfVolume,
+                             const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect)& theShapeClipping);
+  
+  Standard_EXPORT void SetShapeClipping(const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect)& theShapeClipping)
+  {
+    myShapeClipping = theShapeClipping;
+  }
+
+  Standard_EXPORT const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect) ShapeClipping()
+  {
+    return myShapeClipping;
+  }
+  DEFINE_STANDARD_RTTIEXT(StepVisual_CameraModelD3MultiClipping, StepVisual_CameraModelD3)
+  
+private:
+
+Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect) myShapeClipping;
+};
+#endif // _StepVisual_CameraModelD3MultiClipping_HeaderFile

src/StepVisual/StepVisual_CameraModelD3MultiClippingInterectionSelect.cxx

@@ -0,0 +1,45 @@
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// Copyright (c) 2015 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.
+
+#include <StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx>
+#include <Interface_Macros.hxx>
+#include <StepGeom_Plane.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+
+//=======================================================================
+//function : StepVisual_CameraModelD3MultiClippingInterectionSelect
+//purpose  : 
+//=======================================================================
+StepVisual_CameraModelD3MultiClippingInterectionSelect::StepVisual_CameraModelD3MultiClippingInterectionSelect () {  }
+
+//=======================================================================
+//function : CaseNum
+//purpose  : 
+//=======================================================================
+Standard_Integer StepVisual_CameraModelD3MultiClippingInterectionSelect::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+  if (ent.IsNull()) return 0;
+  if (ent->IsKind(STANDARD_TYPE(StepGeom_Plane))) return 1;
+  if (ent->IsInstance(STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingUnion))) return 2;
+  return 0;
+}
+
+Handle(StepGeom_Plane) StepVisual_CameraModelD3MultiClippingInterectionSelect::Plane() const
+{  return GetCasted(StepGeom_Plane, Value());  }
+
+Handle(StepVisual_CameraModelD3MultiClippingUnion) StepVisual_CameraModelD3MultiClippingInterectionSelect::CameraModelD3MultiClippingUnion() const
+{
+  return GetCasted(StepVisual_CameraModelD3MultiClippingUnion, Value());
+}

src/StepVisual/StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx

@@ -0,0 +1,51 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_CameraModelD3MultiClippingInterectionSelect_HeaderFile
+#define _StepVisual_CameraModelD3MultiClippingInterectionSelect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+class Standard_Transient;
+class StepGeom_Plane;
+class StepVisual_CameraModelD3MultiClippingUnion;
+
+class StepVisual_CameraModelD3MultiClippingInterectionSelect  : public StepData_SelectType
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  //! Returns a CameraModelD3MultiClippingInterectionSelect select type
+  Standard_EXPORT StepVisual_CameraModelD3MultiClippingInterectionSelect();
+  
+  //! Recognizes a IdAttributeSelect Kind Entity that is :
+  //! 1 -> Plane
+  //! 2 -> CameraModelD3MultiClippingUnion
+  //! 0 else
+  Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent)  const;
+  
+  //! returns Value as a Plane (Null if another type)
+  Standard_EXPORT Handle(StepGeom_Plane) Plane()  const;
+
+  //! returns Value as a CameraModelD3MultiClippingUnion (Null if another type)
+  Standard_EXPORT Handle(StepVisual_CameraModelD3MultiClippingUnion) CameraModelD3MultiClippingUnion()  const;
+
+};
+#endif // StepVisual_CameraModelD3MultiClippingInterectionSelect

src/StepVisual/StepVisual_CameraModelD3MultiClippingIntersection.cxx

@@ -0,0 +1,41 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CameraModelD3MultiClippingIntersection, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepVisual_CameraModelD3MultiClippingIntersection
+//purpose  : 
+//=======================================================================
+StepVisual_CameraModelD3MultiClippingIntersection::StepVisual_CameraModelD3MultiClippingIntersection()  {}
+
+//=======================================================================
+//function : Init
+//purpose  : 
+//=======================================================================
+void StepVisual_CameraModelD3MultiClippingIntersection::Init(
+  const Handle(TCollection_HAsciiString)& theName,
+  const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect)& theShapeClipping)
+{
+  // Own field
+  myShapeClipping = theShapeClipping;
+  // Inherited fields
+  StepGeom_GeometricRepresentationItem::Init(theName);
+}

src/StepVisual/StepVisual_CameraModelD3MultiClippingIntersection.hxx

@@ -0,0 +1,55 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_CameraModelD3MultiClippingIntersction_HeaderFile
+#define _StepVisual_CameraModelD3MultiClippingIntersction_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepGeom_GeometricRepresentationItem.hxx>
+class StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect;
+class TCollection_HAsciiString;
+
+class StepGeom_GeometricRepresentationItem;
+DEFINE_STANDARD_HANDLE(StepVisual_CameraModelD3MultiClippingIntersection, StepGeom_GeometricRepresentationItem)
+
+class StepVisual_CameraModelD3MultiClippingIntersection : public StepGeom_GeometricRepresentationItem
+{
+public:
+
+  
+  //! Returns a StepVisual_CameraModelD3MultiClippingIntersection
+  Standard_EXPORT StepVisual_CameraModelD3MultiClippingIntersection();
+  
+  Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+                             const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect)& theShapeClipping);
+  
+  Standard_EXPORT void SetShapeClipping(const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect)& theShapeClipping)
+  {
+    myShapeClipping = theShapeClipping;
+  }
+
+  Standard_EXPORT const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect) ShapeClipping()
+  {
+    return myShapeClipping;
+  }
+  DEFINE_STANDARD_RTTIEXT(StepVisual_CameraModelD3MultiClippingIntersection, StepGeom_GeometricRepresentationItem)
+  
+private:
+
+Handle(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect) myShapeClipping;
+};
+#endif // _StepVisual_CameraModelD3MultiClippingIntersection_HeaderFile

src/StepVisual/StepVisual_CameraModelD3MultiClippingUnion.cxx

@@ -0,0 +1,41 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CameraModelD3MultiClippingUnion, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepVisual_CameraModelD3MultiClippingUnion
+//purpose  : 
+//=======================================================================
+StepVisual_CameraModelD3MultiClippingUnion::StepVisual_CameraModelD3MultiClippingUnion()  {}
+
+//=======================================================================
+//function : Init
+//purpose  : 
+//=======================================================================
+void StepVisual_CameraModelD3MultiClippingUnion::Init(
+  const Handle(TCollection_HAsciiString)& theName,
+  const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect)& theShapeClipping)
+{
+  // Own field
+  myShapeClipping = theShapeClipping;
+  // Inherited fields
+  StepGeom_GeometricRepresentationItem::Init(theName);
+}

src/StepVisual/StepVisual_CameraModelD3MultiClippingUnion.hxx

@@ -0,0 +1,55 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_CameraModelD3MultiClippingUnion_HeaderFile
+#define _StepVisual_CameraModelD3MultiClippingUnion_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepGeom_GeometricRepresentationItem.hxx>
+class StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect;
+class TCollection_HAsciiString;
+
+class StepGeom_GeometricRepresentationItem;
+DEFINE_STANDARD_HANDLE(StepVisual_CameraModelD3MultiClippingUnion, StepGeom_GeometricRepresentationItem)
+
+class StepVisual_CameraModelD3MultiClippingUnion : public StepGeom_GeometricRepresentationItem
+{
+public:
+
+  
+  //! Returns a StepVisual_CameraModelD3MultiClippingUnion
+  Standard_EXPORT StepVisual_CameraModelD3MultiClippingUnion();
+  
+  Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+                             const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect)& theShapeClipping);
+  
+  Standard_EXPORT void SetShapeClipping(const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect)& theShapeClipping)
+  {
+    myShapeClipping = theShapeClipping;
+  }
+
+  Standard_EXPORT const Handle(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect) ShapeClipping()
+  {
+    return myShapeClipping;
+  }
+  DEFINE_STANDARD_RTTIEXT(StepVisual_CameraModelD3MultiClippingUnion, StepGeom_GeometricRepresentationItem)
+  
+private:
+
+Handle(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect) myShapeClipping;
+};
+#endif // _StepVisual_CameraModelD3MultiClippingUnion_HeaderFile

src/StepVisual/StepVisual_CameraModelD3MultiClippingUnionSelect.cxx

@@ -0,0 +1,47 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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.
+
+#include <StepVisual_CameraModelD3MultiClippingUnionSelect.hxx>
+#include <Interface_Macros.hxx>
+#include <StepGeom_Plane.hxx>
+#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
+
+//=======================================================================
+//function : StepVisual_CameraModelD3MultiClippingUnionSelect
+//purpose  : 
+//=======================================================================
+StepVisual_CameraModelD3MultiClippingUnionSelect::StepVisual_CameraModelD3MultiClippingUnionSelect () {  }
+
+//=======================================================================
+//function : CaseNum
+//purpose  : 
+//=======================================================================
+Standard_Integer StepVisual_CameraModelD3MultiClippingUnionSelect::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+  if (ent.IsNull()) return 0;
+  if (ent->IsKind(STANDARD_TYPE(StepGeom_Plane))) return 1;
+  if (ent->IsInstance(STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingIntersection))) return 2;
+  return 0;
+}
+
+Handle(StepGeom_Plane) StepVisual_CameraModelD3MultiClippingUnionSelect::Plane() const
+{
+  return GetCasted(StepGeom_Plane, Value());
+}
+
+Handle(StepVisual_CameraModelD3MultiClippingIntersection) StepVisual_CameraModelD3MultiClippingUnionSelect::CameraModelD3MultiClippingIntersection() const
+{
+  return GetCasted(StepVisual_CameraModelD3MultiClippingIntersection, Value());
+}

src/StepVisual/StepVisual_CameraModelD3MultiClippingUnionSelect.hxx

@@ -0,0 +1,51 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_CameraModelD3MultiClippingUnionSelect_HeaderFile
+#define _StepVisual_CameraModelD3MultiClippingUnionSelect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+class Standard_Transient;
+class StepGeom_Plane;
+class StepVisual_CameraModelD3MultiClippingIntersection;
+
+class StepVisual_CameraModelD3MultiClippingUnionSelect  : public StepData_SelectType
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  //! Returns a CameraModelD3MultiClippingUnionSelect select type
+  Standard_EXPORT StepVisual_CameraModelD3MultiClippingUnionSelect();
+  
+  //! Recognizes a IdAttributeSelect Kind Entity that is :
+  //! 1 -> Plane
+  //! 2 -> CameraModelD3MultiClippingIntersection
+  //! 0 else
+  Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent)  const;
+  
+  //! returns Value as a Plane (Null if another type)
+  Standard_EXPORT Handle(StepGeom_Plane) Plane()  const;
+
+  //! returns Value as a CameraModelD3MultiClippingIntersection (Null if another type)
+  Standard_EXPORT Handle(StepVisual_CameraModelD3MultiClippingIntersection) CameraModelD3MultiClippingIntersection()  const;
+
+};
+#endif // StepVisual_CameraModelD3MultiClippingUnionSelect

src/StepVisual/StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx

@@ -0,0 +1,24 @@
+// Created on: 2016-10-25
+// Created by: Irina KRYLOVA
+// Copyright (c) 2015 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 _StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect_HeaderFile
+#define _StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect_HeaderFile
+
+#include <StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx>
+#include <StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect, StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect)
+#endif // _StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect_HeaderFile

src/StepVisual/StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx

@@ -0,0 +1,24 @@
+// Created on: 2016-11-14
+// Created by: Irina KRYLOVA
+// Copyright (c) 2016 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 _StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect_HeaderFile
+#define _StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect_HeaderFile
+
+#include <StepVisual_CameraModelD3MultiClippingUnionSelect.hxx>
+#include <StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect, StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect)
+#endif // _StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect_HeaderFile

src/TKVRML/EXTERNLIB

@@ -11,3 +11,4 @@ TKHLR
 TKService
 TKGeomAlgo
 TKV3d
+TKSTL

src/TKXCAF/PACKAGES

@@ -2,3 +2,4 @@ XCAFApp
 XCAFDimTolObjects
 XCAFDoc
 XCAFPrs
+XCAFView

src/ViewerTest/ViewerTest_ViewerCommands.cxx

@@ -9065,6 +9065,8 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
     }
     theDI << "\n";
     theDI << "msaa:           " <<  aParams.NbMsaaSamples                               << "\n";
+    theDI << "oit:            " << (aParams.IsOitEnabled                ? "on" : "off") << "\n";
+    theDI << "oitDepthWeight: " <<  aParams.OitDepthWeight                              << "\n";
     theDI << "rayDepth:       " <<  aParams.RaytracingDepth                             << "\n";
     theDI << "fsaa:           " << (aParams.IsAntialiasingEnabled       ? "on" : "off") << "\n";
     theDI << "shadows:        " << (aParams.IsShadowEnabled             ? "on" : "off") << "\n";
@@ -9171,6 +9173,46 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
         aParams.NbMsaaSamples = aNbSamples;
       }
     }
+    else if (aFlag == "-oit")
+    {
+      if (toPrint)
+      {
+        theDI << (aParams.IsOitEnabled ? "on" : "off") << " ";
+        continue;
+      }
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aParams.IsOitEnabled = toEnable;
+    }
+    else if (aFlag == "-oitdepth"
+          || aFlag == "-oitdepthweight")
+    {
+      if (toPrint)
+      {
+        theDI << aParams.OitDepthWeight << " ";
+        continue;
+      }
+      else if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+        return 1;
+      }
+      const Standard_Real aWeight = Draw::Atof (theArgVec[anArgIter]);
+
+      if (aWeight < 0.0 || aWeight > 1.0)
+      {
+        std::cerr << "Error: invalid value of order-indepedent transparency depth weight " << aWeight << ". Should be within range [0.0; 1.0]\n";
+        return 1;
+      }
+      else
+      {
+        aParams.OitDepthWeight = static_cast<Standard_ShortReal> (aWeight);
+      }
+    }
     else if (aFlag == "-raydepth"
           || aFlag == "-ray_depth")
     {
@@ -10926,6 +10968,8 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     "\n    Manages rendering parameters: "
     "\n      '-raster'               Disables GPU ray-tracing"
     "\n      '-msaa         0..4'    Specifies number of samples for MSAA"
+    "\n      '-oit            on|off'  Enables/disables blended order-independent transparency"
+    "\n      '-oitDepthWeight 0.0-1.0' Defines influence of fragment depth to its coverage"
     "\n      '-rayTrace'             Enables  GPU ray-tracing"
     "\n      '-rayDepth     0..10'   Defines maximum ray-tracing depth"
     "\n      '-shadows      on|off'  Enables/disables shadows rendering"

src/VrmlData/VrmlData_Geometry.cxx

@@ -650,7 +650,15 @@ VrmlData_ErrorStatus VrmlData_ArrayVec3d::ReadArray
     // Read the body of the data node (list of triplets)
     if (OK(aStatus) && OK(aStatus, VrmlData_Scene::ReadLine(theBuffer))) {
       if (theBuffer.LinePtr[0] != '[')  // opening bracket
-        aStatus = VrmlData_VrmlFormatError;
+      {
+        // Handle case when brackets are ommited for single element of array
+        gp_XYZ anXYZ;
+        // Read three numbers (XYZ value)
+        if (!OK(aStatus, Scene().ReadXYZ(theBuffer, anXYZ,
+                                          isScale, Standard_False)))
+          aStatus = VrmlData_VrmlFormatError;
+        vecValues.Append(anXYZ);
+      }
       else {
         theBuffer.LinePtr++;
         for(;;) {

src/VrmlData/VrmlData_Group.cxx

@@ -203,6 +203,10 @@ VrmlData_ErrorStatus VrmlData_Group::Read (VrmlData_InBuffer& theBuffer)
           break;
       }
     }
+    else if (VRMLDATA_LCOMPARE(theBuffer.LinePtr, "collide")) {
+      TCollection_AsciiString aDummy;
+      aStatus = Scene().ReadWord (theBuffer, aDummy);
+    }
     else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "Separator") ||
              VRMLDATA_LCOMPARE (theBuffer.LinePtr, "Switch")) {
       Standard_Boolean isBracketed (Standard_False);

src/VrmlData/VrmlData_IndexedFaceSet.cxx

@@ -29,6 +29,26 @@
 #include <Poly.hxx>
 #include <TShort_HArray1OfShortReal.hxx>
 
+#include <TopoDS_Face.hxx>
+#include <BRep_Tool.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Wire.hxx>
+#include <BRepBuilderAPI_Sewing.hxx>
+#include <TopoDS_Compound.hxx>
+#include <BRep_Builder.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS.hxx>
+#include <BRepBuilderAPI_CellFilter.hxx>
+#include <StlMesh_Mesh.hxx>
+#include <StlMesh_MeshExplorer.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <StlAPI.hxx>
+#include <ShapeUpgrade_UnifySameDomain.hxx>
+#include <BRepClass3d_SolidClassifier.hxx>
+#include <ShapeUpgrade_CombineToCylinder.hxx>
+
 IMPLEMENT_STANDARD_RTTIEXT(VrmlData_IndexedFaceSet,VrmlData_Faceted)
 
 #ifdef _MSC_VER
@@ -36,8 +56,239 @@ IMPLEMENT_STANDARD_RTTIEXT(VrmlData_IndexedFaceSet,VrmlData_Faceted)
 #pragma warning (disable:4996)
 #endif
 
+// Auxiliary tools
+namespace
+{
+  // Tool to get triangles from triangulation taking into account face
+  // orientation and location
+  class TriangleAccessor
+  {
+  public:
+    TriangleAccessor (const TopoDS_Face& aFace)
+    {
+      TopLoc_Location aLoc;
+      myPoly = BRep_Tool::Triangulation (aFace, aLoc);
+      myTrsf = aLoc.Transformation();
+      myNbTriangles = (myPoly.IsNull() ? 0 : myPoly->Triangles().Length());
+      myInvert = (aFace.Orientation() == TopAbs_REVERSED);
+      if (myTrsf.IsNegative())
+        myInvert = ! myInvert;
+    }
 
+    int NbTriangles () const { return myNbTriangles; } 
 
+    // get i-th triangle and outward normal
+    void GetTriangle (int iTri, gp_Vec &theNormal, gp_Pnt &thePnt1, gp_Pnt &thePnt2, gp_Pnt &thePnt3)
+    {
+      // get positions of nodes
+      int iNode1, iNode2, iNode3;
+      myPoly->Triangles()(iTri).Get (iNode1, iNode2, iNode3);
+      thePnt1 = myPoly->Nodes()(iNode1);
+      thePnt2 = myPoly->Nodes()(myInvert ? iNode3 : iNode2);
+      thePnt3 = myPoly->Nodes()(myInvert ? iNode2 : iNode3);
+
+      // apply transormation if not identity
+      if (myTrsf.Form() != gp_Identity)
+      {
+        thePnt1.Transform (myTrsf);
+        thePnt2.Transform (myTrsf);
+        thePnt3.Transform (myTrsf);
+      }
+
+      // calculate normal
+      theNormal = (thePnt2.XYZ() - thePnt1.XYZ()) ^ (thePnt3.XYZ() - thePnt1.XYZ());
+      Standard_Real aNorm = theNormal.Magnitude();
+      if (aNorm > gp::Resolution())
+        theNormal /= aNorm;
+    }
+
+  private:
+    Handle(Poly_Triangulation) myPoly;
+    gp_Trsf myTrsf;
+    int myNbTriangles;
+    bool myInvert;
+  };
+
+  // convert to float and, on big-endian platform, to little-endian representation
+  inline float convertFloat (Standard_Real aValue)
+  {
+#ifdef OCCT_BINARY_FILE_DO_INVERSE
+    return OSD_BinaryFile::InverseShortReal ((float)aValue);
+#else
+    return (float)aValue;
+#endif
+  }
+
+  // A static method adding nodes to a mesh and keeping coincident (sharing) nodes.
+  static Standard_Integer AddVertex(Handle(StlMesh_Mesh)& mesh,
+                                    BRepBuilderAPI_CellFilter& filter, 
+                                    BRepBuilderAPI_VertexInspector& inspector,
+                                    const gp_XYZ& p)
+  {
+    Standard_Integer index;
+    inspector.SetCurrent(p);
+    gp_XYZ minp = inspector.Shift(p, -Precision::Confusion());
+    gp_XYZ maxp = inspector.Shift(p, +Precision::Confusion());
+    filter.Inspect(minp, maxp, inspector);
+    const TColStd_ListOfInteger& indices = inspector.ResInd();
+    if (indices.IsEmpty() == Standard_False)
+    {
+      index = indices.First(); // it should be only one
+      inspector.ClearResList();
+    }
+    else
+    {
+      index = mesh->AddVertex(p.X(), p.Y(), p.Z());
+      filter.Add(index, p);
+      inspector.Add(p);
+    }
+    return index;
+  }
+
+  void createFromMesh(Handle(TopoDS_TShape)& theShapeWithMesh)
+  {
+    TopoDS_Shape aShape;
+    //aShape.Orientation(TopAbs_FORWARD);
+
+    aShape.TShape(theShapeWithMesh);
+    if (aShape.IsNull())
+      return;
+
+    // Write to STL and then read again to get BRep model (vrml fills only triangulation)
+    //StlAPI::Write(aShape, "D:/Temp/tempfile");
+    //StlAPI::Read(aShape, "D:/Temp/tempfile");
+
+    gp_XYZ p1, p2, p3;
+    TopoDS_Vertex Vertex1, Vertex2, Vertex3;
+    TopoDS_Face AktFace;
+    TopoDS_Wire AktWire;
+    BRepBuilderAPI_Sewing aSewingTool;
+    Standard_Real x1, y1, z1;
+    Standard_Real x2, y2, z2;
+    Standard_Real x3, y3, z3;
+    Standard_Integer i1,i2,i3;
+  
+    aSewingTool.Init(1.0e-06,Standard_True);
+  
+    TopoDS_Compound aComp;
+    BRep_Builder BuildTool;
+    BuildTool.MakeCompound( aComp );
+
+    Handle(StlMesh_Mesh) aSTLMesh = new StlMesh_Mesh();
+    aSTLMesh->AddDomain();
+
+    // Filter unique vertices to share the nodes of the mesh.
+    BRepBuilderAPI_CellFilter uniqueVertices(Precision::Confusion());
+    BRepBuilderAPI_VertexInspector inspector(Precision::Confusion());
+
+    // Read mesh
+    for (TopExp_Explorer exp (aShape, TopAbs_FACE); exp.More(); exp.Next())
+    {
+      TriangleAccessor aTool (TopoDS::Face (exp.Current()));
+      for (int iTri = 1; iTri <= aTool.NbTriangles(); iTri++)
+      {
+        gp_Vec aNorm;
+        gp_Pnt aPnt1, aPnt2, aPnt3;
+        aTool.GetTriangle(iTri, aNorm, aPnt1, aPnt2, aPnt3);
+
+        i1 = AddVertex(aSTLMesh, uniqueVertices, inspector, aPnt1.XYZ());
+        i2 = AddVertex(aSTLMesh, uniqueVertices, inspector, aPnt2.XYZ());
+        i3 = AddVertex(aSTLMesh, uniqueVertices, inspector, aPnt3.XYZ());
+        aSTLMesh->AddTriangle(i1, i2, i3, aNorm.X(), aNorm.Y(), aNorm.Z());
+      }
+    }
+
+    StlMesh_MeshExplorer aMExp (aSTLMesh);
+    Standard_Integer NumberDomains = aSTLMesh->NbDomains();
+    Standard_Integer iND;
+    for (iND=1;iND<=NumberDomains;iND++) 
+    {
+      for (aMExp.InitTriangle (iND); aMExp.MoreTriangle (); aMExp.NextTriangle ()) 
+      {
+        aMExp.TriangleVertices (x1,y1,z1,x2,y2,z2,x3,y3,z3);
+        p1.SetCoord(x1,y1,z1);
+        p2.SetCoord(x2,y2,z2);
+        p3.SetCoord(x3,y3,z3);
+      
+        if ((!(p1.IsEqual(p2,0.0))) && (!(p1.IsEqual(p3,0.0))))
+        {
+          Vertex1 = BRepBuilderAPI_MakeVertex(p1);
+          Vertex2 = BRepBuilderAPI_MakeVertex(p2);
+          Vertex3 = BRepBuilderAPI_MakeVertex(p3);
+        
+          AktWire = BRepBuilderAPI_MakePolygon( Vertex1, Vertex2, Vertex3, Standard_True);
+        
+          if( !AktWire.IsNull())
+          {
+            AktFace = BRepBuilderAPI_MakeFace( AktWire);
+            if(!AktFace.IsNull())
+              BuildTool.Add( aComp, AktFace );
+          }
+        }
+      }
+    }
+    aSTLMesh->Clear();
+
+    aSewingTool.Init();
+    aSewingTool.Load( aComp );
+    aSewingTool.Perform();
+    aShape = aSewingTool.SewedShape();
+    if ( aShape.IsNull() )
+      aShape = aComp;
+
+    ShapeUpgrade_UnifySameDomain anUSD(aShape);
+    anUSD.SetLinearTolerance(1e-5);
+    anUSD.Build();
+    aShape = anUSD.Shape();
+
+    if (aShape.ShapeType() == TopAbs_SHELL && TopoDS::Shell(aShape).Closed())
+    {
+      TopoDS_Solid aSolid;
+      TopoDS_Shell aShell = TopoDS::Shell (aShape);
+      if (!aShell.Free ()) {
+        aShell.Free(Standard_True);
+      }
+      BRep_Builder aBuilder;
+      aBuilder.MakeSolid (aSolid);
+      aBuilder.Add (aSolid, aShell);
+
+      Standard_Boolean isOk = Standard_True;
+      try {
+        OCC_CATCH_SIGNALS
+        BRepClass3d_SolidClassifier bsc3d (aSolid);
+        Standard_Real t = Precision::Confusion();
+        bsc3d.PerformInfinitePoint(t);
+
+        if (bsc3d.State() == TopAbs_IN) {
+          TopoDS_Solid aSolid2;
+          aBuilder.MakeSolid (aSolid2);
+          aShell.Reverse();
+          aBuilder.Add (aSolid2, aShell);
+          aSolid = aSolid2;
+        }
+      }
+      catch (Standard_Failure) { isOk = Standard_False; }
+      if (isOk) aShape = aSolid;
+    }
+
+    // Trying to apply "Combine to Cylinder"
+
+    //ShapeUpgrade_CombineToCylinder cmb2Cyl;
+    //Standard_Boolean isOk = Standard_True;
+    //try {
+    //  OCC_CATCH_SIGNALS
+    //  cmb2Cyl.SetShape(aShape);
+    //  cmb2Cyl.SetAngularTolerance(20);
+    //  cmb2Cyl.SetLinearTolerance(3);
+    //  cmb2Cyl.Build();
+    //}
+    //catch (Standard_Failure) { isOk = Standard_False; }
+    //if (isOk && cmb2Cyl.IsDone())
+    //  aShape = cmb2Cyl.Shape();
+
+    theShapeWithMesh = aShape.TShape();
+  }
+}
 
 //=======================================================================
 //function : readData
@@ -210,6 +461,7 @@ const Handle(TopoDS_TShape)& VrmlData_IndexedFaceSet::TShape ()
 
     myIsModified = Standard_False;
   }
+  //createFromMesh(myTShape);
   return myTShape;
 }
 

src/VrmlData/VrmlData_IndexedLineSet.cxx

@@ -55,34 +55,34 @@ Quantity_Color VrmlData_IndexedLineSet::GetColor
 
 const Handle(TopoDS_TShape)& VrmlData_IndexedLineSet::TShape ()
 {
-  if (myNbPolygons == 0)
-    myTShape.Nullify();
-  else if (myIsModified) {
-    Standard_Integer i;
-    BRep_Builder aBuilder;
-    const gp_XYZ * arrNodes = myCoords->Values();
+  //if (myNbPolygons == 0)
+  //  myTShape.Nullify();
+  //else if (myIsModified) {
+  //  Standard_Integer i;
+  //  BRep_Builder aBuilder;
+  //  const gp_XYZ * arrNodes = myCoords->Values();
 
-    // Create the Wire
-    TopoDS_Wire aWire;
-    aBuilder.MakeWire(aWire);
-    for (i = 0; i < (int)myNbPolygons; i++) {
-      const Standard_Integer * arrIndice;
-      const Standard_Integer nNodes = Polygon(i, arrIndice);
-      TColgp_Array1OfPnt   arrPoint (1, nNodes);
-      TColStd_Array1OfReal arrParam (1, nNodes);
-      for (Standard_Integer j = 0; j < nNodes; j++) {
-        arrPoint(j+1).SetXYZ (arrNodes[arrIndice[j]]);
-        arrParam(j+1) = j;
-      }
-      const Handle(Poly_Polygon3D) aPolyPolygon =
-        new Poly_Polygon3D (arrPoint, arrParam);
-      TopoDS_Edge anEdge;
-      aBuilder.MakeEdge (anEdge, aPolyPolygon);
-      aBuilder.Add (aWire, anEdge);
-    }
-    myTShape = aWire.TShape();
-  }
-  return myTShape;
+  //  // Create the Wire
+  //  TopoDS_Wire aWire;
+  //  aBuilder.MakeWire(aWire);
+  //  for (i = 0; i < (int)myNbPolygons; i++) {
+  //    const Standard_Integer * arrIndice;
+  //    const Standard_Integer nNodes = Polygon(i, arrIndice);
+  //    TColgp_Array1OfPnt   arrPoint (1, nNodes);
+  //    TColStd_Array1OfReal arrParam (1, nNodes);
+  //    for (Standard_Integer j = 0; j < nNodes; j++) {
+  //      arrPoint(j+1).SetXYZ (arrNodes[arrIndice[j]]);
+  //      arrParam(j+1) = j;
+  //    }
+  //    const Handle(Poly_Polygon3D) aPolyPolygon =
+  //      new Poly_Polygon3D (arrPoint, arrParam);
+  //    TopoDS_Edge anEdge;
+  //    aBuilder.MakeEdge (anEdge, aPolyPolygon);
+  //    aBuilder.Add (aWire, anEdge);
+  //  }
+  //  myTShape = aWire.TShape();
+  //}
+  return Handle(TopoDS_TShape)();
 }
 
 //=======================================================================

src/VrmlData/VrmlData_Scene.cxx

@@ -497,6 +497,9 @@ VrmlData_ErrorStatus VrmlData_Scene::createNode
     else if (VRMLDATA_LCOMPARE(theBuffer.LinePtr, "Separator"))
       aNode = new VrmlData_Group          (* this, strName,
                                            Standard_False);
+    else if (VRMLDATA_LCOMPARE(theBuffer.LinePtr, "Collision"))
+      aNode = new VrmlData_Group          (* this, strName,
+                                           Standard_False);
     else if (VRMLDATA_LCOMPARE(theBuffer.LinePtr, "Switch"))
       aNode = new VrmlData_Group          (* this, strName,
                                            Standard_False);

src/XCAFDoc/FILES

@@ -2,10 +2,17 @@ FILES
 GUID.txt
 XCAFDoc.cxx
 XCAFDoc.hxx
+XCAFDoc_AssemblyItemId.cxx
+XCAFDoc_AssemblyItemId.hxx
+XCAFDoc_AssemblyItemRef.cxx
+XCAFDoc_AssemblyItemRef.hxx
+XCAFDoc_PartId.hxx
 XCAFDoc_Area.cxx
 XCAFDoc_Area.hxx
 XCAFDoc_Centroid.cxx
 XCAFDoc_Centroid.hxx
+XCAFDoc_ClippingPlaneTool.cxx
+XCAFDoc_ClippingPlaneTool.hxx
 XCAFDoc_Color.cxx
 XCAFDoc_Color.hxx
 XCAFDoc_ColorTool.cxx
@@ -38,9 +45,21 @@ XCAFDoc_Material.cxx
 XCAFDoc_Material.hxx
 XCAFDoc_MaterialTool.cxx
 XCAFDoc_MaterialTool.hxx
+XCAFDoc_Note.cxx
+XCAFDoc_Note.hxx
+XCAFDoc_NoteComment.cxx
+XCAFDoc_NoteComment.hxx
+XCAFDoc_NoteBinData.cxx
+XCAFDoc_NoteBinData.hxx
+XCAFDoc_NotesTool.cxx
+XCAFDoc_NotesTool.hxx
 XCAFDoc_ShapeMapTool.cxx
 XCAFDoc_ShapeMapTool.hxx
 XCAFDoc_ShapeTool.cxx
 XCAFDoc_ShapeTool.hxx
+XCAFDoc_View.cxx
+XCAFDoc_View.hxx
+XCAFDoc_ViewTool.cxx
+XCAFDoc_ViewTool.hxx
 XCAFDoc_Volume.cxx
 XCAFDoc_Volume.hxx

src/XCAFDoc/XCAFDoc.cxx

@@ -172,6 +172,17 @@ Standard_GUID XCAFDoc::MaterialRefGUID ()
 }
 
 
+//=======================================================================
+//function : NoteRefGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::NoteRefGUID()
+{
+  static Standard_GUID ID ("F3599E50-F84A-493e-8D1B-1284E79322F1");
+  return ID;
+}
+
 //=======================================================================
 //function : InvisibleGUID
 //purpose  : 
@@ -194,3 +205,78 @@ Standard_GUID XCAFDoc::SHUORefGUID ()
   static Standard_GUID ID ("efd212ea-6dfd-11d4-b9c8-0060b0ee281b");
   return ID;
 }
+
+//=======================================================================
+//function : ViewRefGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::ViewRefGUID()
+{
+  static Standard_GUID ID("efd213e5-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}
+
+//=======================================================================
+//function : ViewRefShapeGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::ViewRefShapeGUID()
+{
+  static Standard_GUID ID("efd213e6-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}
+
+//=======================================================================
+//function : ViewRefGDTGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::ViewRefGDTGUID()
+{
+  static Standard_GUID ID("efd213e7-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}
+
+//=======================================================================
+//function : ViewRefPlaneGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::ViewRefPlaneGUID()
+{
+  static Standard_GUID ID("efd213e9-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}
+
+//=======================================================================
+//function : ViewRefNoteGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::ViewRefNoteGUID()
+{
+  static Standard_GUID ID("efd213e2-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}
+//=======================================================================
+//function : ViewRefEnabledShapesGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::ViewRefEnabledShapesGUID()
+{
+  static Standard_GUID ID("efd213e4-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}
+//=======================================================================
+//function : LockGUID
+//purpose  : 
+//=======================================================================
+
+Standard_GUID XCAFDoc::LockGUID()
+{
+  static Standard_GUID ID("efd213eb-6dfd-11d4-b9c8-0060b0ee281b");
+  return ID;
+}