0030691: Data Exchange - implement import of mesh data from files in glTF format

Added RWGltf_CafReader class implementing glTF reader.
Added readgltf Draw Harness command for reading glTF files.

CMakeLists.txt

@@ -633,6 +633,26 @@ else()
   OCCT_CHECK_AND_UNSET ("INSTALL_TBB")
 endif()
 
+# RapidJSON
+# search for CSF_RapidJSON variable in EXTERNLIB of each being used toolkit
+OCCT_IS_PRODUCT_REQUIRED (CSF_RapidJSON CAN_USE_RAPIDJSON)
+if (CAN_USE_RAPIDJSON)
+  set (USE_RAPIDJSON OFF CACHE BOOL "${USE_RAPIDJSON_DESCR}")
+
+  if (USE_RAPIDJSON)
+    add_definitions (-DHAVE_RAPIDJSON)
+    OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/rapidjson")
+  else()
+    OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_RAPIDJSON")
+    OCCT_CHECK_AND_UNSET ("INSTALL_RAPIDJSON")
+  endif()
+else()
+  OCCT_CHECK_AND_UNSET ("USE_RAPIDJSON")
+
+  OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_RAPIDJSON")
+  OCCT_CHECK_AND_UNSET ("INSTALL_RAPIDJSON")
+endif()
+
 # EIGEN
 if (CAN_USE_EIGEN)
   set (USE_EIGEN OFF CACHE BOOL "${USE_EIGEN_DESCR}")

adm/UDLIST

@@ -440,4 +440,5 @@ t TKVCAF
 n XCAFView
 n XCAFNoteObjects
 t TKRWMesh
+n RWGltf
 n RWMesh

adm/cmake/rapidjson.cmake

@@ -0,0 +1,86 @@
+# RapidJSON
+
+if (NOT DEFINED INSTALL_RAPIDJSON)
+  set (INSTALL_RAPIDJSON OFF CACHE BOOL "${INSTALL_RAPIDJSON_DESCR}")
+endif()
+
+# RapidJSON directory
+if (NOT DEFINED 3RDPARTY_RAPIDJSON_DIR)
+  set (3RDPARTY_RAPIDJSON_DIR "" CACHE PATH "The directory containing RapidJSON")
+endif()
+
+# search for RapidJSON in user defined directory
+if (3RDPARTY_DIR AND EXISTS "${3RDPARTY_DIR}")
+  if (NOT 3RDPARTY_RAPIDJSON_DIR OR NOT EXISTS "${3RDPARTY_RAPIDJSON_DIR}")
+    FIND_PRODUCT_DIR("${3RDPARTY_DIR}" RapidJSON RAPIDJSON_DIR_NAME)
+    if (RAPIDJSON_DIR_NAME)
+      set (3RDPARTY_RAPIDJSON_DIR "${3RDPARTY_DIR}/${RAPIDJSON_DIR_NAME}" CACHE PATH "The directory containing RapidJSON" FORCE)
+    endif()
+  endif()
+endif()
+
+if (NOT DEFINED 3RDPARTY_RAPIDJSON_INCLUDE_DIR)
+  set (3RDPARTY_RAPIDJSON_INCLUDE_DIR  "" CACHE FILEPATH "The directory containing headers of the RAPIDJSON")
+endif()
+
+if (NOT 3RDPARTY_RAPIDJSON_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_RAPIDJSON_INCLUDE_DIR}")
+
+  set (HEADER_NAMES rapidjson/rapidjson.h)
+
+  set (3RDPARTY_RAPIDJSON_INCLUDE_DIR "3RDPARTY_RAPIDJSON_INCLUDE_DIR-NOTFOUND" CACHE PATH "the path to RapidJSON header file" FORCE)
+
+  if (3RDPARTY_RAPIDJSON_DIR AND EXISTS "${3RDPARTY_RAPIDJSON_DIR}")
+    find_path (3RDPARTY_RAPIDJSON_INCLUDE_DIR NAMES ${HEADER_NAMES}
+                                              PATHS ${3RDPARTY_RAPIDJSON_DIR}
+                                              PATH_SUFFIXES include rapidjson
+                                              CMAKE_FIND_ROOT_PATH_BOTH
+                                              NO_DEFAULT_PATH)
+  else()
+    find_path (3RDPARTY_RAPIDJSON_INCLUDE_DIR NAMES ${HEADER_NAMES}
+                                              PATH_SUFFIXES include rapidjson
+                                              CMAKE_FIND_ROOT_PATH_BOTH)
+  endif()
+
+  # use default (CMake) RapidJSON search
+  if (NOT 3RDPARTY_RAPIDJSON_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_RAPIDJSON_INCLUDE_DIR}")
+    if (3RDPARTY_RAPIDJSON_DIR AND EXISTS "${3RDPARTY_RAPIDJSON_DIR}")
+      set (CACHED_RAPIDJSON_DIR $ENV{RapidJSON_DIR})
+      set (ENV{RapidJSON_DIR} "${3RDPARTY_RAPIDJSON_DIR}")
+    endif()
+
+    find_package(RapidJSON QUIET)
+
+    # restore ENV{RapidJSON_DIR}
+    if (3RDPARTY_RAPIDJSON_DIR AND EXISTS "${3RDPARTY_RAPIDJSON_DIR}")
+      set (ENV{RapidJSON_DIR} ${CACHED_RAPIDJSON_DIR})
+    endif()
+
+    if (${RAPIDJSON_FOUND})
+      set (3RDPARTY_RAPIDJSON_INCLUDE_DIR "${RAPIDJSON_INCLUDE_DIR}" CACHE PATH "the path to RapidJSON header file" FORCE)
+      set (3RDPARTY_RAPIDJSON_DIR         "${RAPIDJSON_ROOT_DIR}"    CACHE PATH "The directory containing RapidJSON" FORCE)
+    endif()
+  endif()
+endif()
+
+if (3RDPARTY_RAPIDJSON_INCLUDE_DIR AND EXISTS "${3RDPARTY_RAPIDJSON_INCLUDE_DIR}")
+  list (APPEND 3RDPARTY_INCLUDE_DIRS "${3RDPARTY_RAPIDJSON_INCLUDE_DIR}")
+
+  # Install header files
+  if (INSTALL_RAPIDJSON)
+    file(GLOB RAPIDJSON_SUBDIRS "${3RDPARTY_RAPIDJSON_INCLUDE_DIR}/*")
+    foreach(SUBDIR ${RAPIDJSON_SUBDIRS})
+      if(IS_DIRECTORY "${SUBDIR}")
+        install (DIRECTORY "${SUBDIR}" DESTINATION "${INSTALL_DIR_INCLUDE}")
+      else()
+        install (FILES "${SUBDIR}" DESTINATION "${INSTALL_DIR_INCLUDE}")
+      endif()
+    endforeach()
+  endif()
+else()
+  list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_RAPIDJSON_INCLUDE_DIR)
+
+  set (3RDPARTY_RAPIDJSON_INCLUDE_DIR "" CACHE PATH "the path to RapidJSON header file" FORCE)
+endif()
+
+# unset all redundant variables
+OCCT_CHECK_AND_UNSET(RapidJSON_DIR)

adm/cmake/vardescr.cmake

@@ -94,6 +94,7 @@ INSTALL_MESSAGE (INSTALL_EGL              "EGL binaries")
 INSTALL_MESSAGE (INSTALL_GLES2            "OpenGL ES 2.0 binaries")
 INSTALL_MESSAGE (INSTALL_FREETYPE         "FreeType binaries")
 INSTALL_MESSAGE (INSTALL_TBB              "TBB binaries")
+INSTALL_MESSAGE (INSTALL_RAPIDJSON        "RapidJSON header files")
 INSTALL_MESSAGE (INSTALL_TCL              "TCL binaries")
 INSTALL_MESSAGE (INSTALL_TK               "TK binaries")
 INSTALL_MESSAGE (INSTALL_VTK              "VTK binaries ")
@@ -161,6 +162,10 @@ set (USE_FREEIMAGE_DESCR
 "Indicates whether Freeimage product should be used in OCCT visualization
 module for support of popular graphics image formats (PNG, BMP etc)")
 
+set (USE_RAPIDJSON_DESCR
+"Indicates whether RapidJSON product should be used in OCCT DataExchange
+module for support of JSON-based formats like glTF")
+
 set (USE_EGL_DESCR
 "Indicates whether EGL should be used in OCCT visualization
 module instead of conventional OpenGL context creation APIs")

adm/genconf.tcl

@@ -189,6 +189,9 @@ proc wokdep:gui:UpdateList {} {
     }
     wokdep:SearchStandardLibrary  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs "liblzma" "lzma.h" "$aCheckLib" {"lzma" "xz"}
   }
+  if { "$::HAVE_RAPIDJSON" == "true" } {
+    wokdep:SearchRapidJson anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
 
   if { "$::CHECK_QT4" == "true" } {
     wokdep:SearchQt4     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
@@ -456,6 +459,9 @@ ttk::label    .myFrame.myChecks.myZLibLbl       -text "Use zlib"
 checkbutton   .myFrame.myChecks.myLzmaCheck     -offvalue "false" -onvalue "true" -variable HAVE_LIBLZMA   -command wokdep:gui:UpdateList
 ttk::label    .myFrame.myChecks.myLzmaLbl       -text "Use liblzma"
 
+checkbutton   .myFrame.myChecks.myRapidJsonCheck -offvalue "false" -onvalue "true" -variable HAVE_RAPIDJSON -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myChecks.myRapidJsonLbl   -text "Use RapidJSON"
+
 checkbutton   .myFrame.myChecks.myQt4Check      -offvalue "false" -onvalue "true" -variable CHECK_QT4      -command wokdep:gui:UpdateList
 ttk::label    .myFrame.myChecks.myQt4Lbl        -text "Search Qt4"
 checkbutton   .myFrame.myChecks.myJDKCheck      -offvalue "false" -onvalue "true" -variable CHECK_JDK      -command wokdep:gui:UpdateList
@@ -564,8 +570,8 @@ if { "$::tcl_platform(os)" != "Darwin" } {
 grid .myFrame.myChecks.myZLibCheck     -row $aCheckRowIter -column 6 -sticky e
 grid .myFrame.myChecks.myZLibLbl       -row $aCheckRowIter -column 7 -sticky w
 
-grid .myFrame.myChecks.myQt4Check      -row $aCheckRowIter -column 10 -sticky e
+grid .myFrame.myChecks.myQt4Check      -row $aCheckRowIter -column 12 -sticky e
-grid .myFrame.myChecks.myQt4Lbl        -row $aCheckRowIter -column 11 -sticky w
+grid .myFrame.myChecks.myQt4Lbl        -row $aCheckRowIter -column 13 -sticky w
 
 incr aCheckRowIter
 grid .myFrame.myChecks.myFFmpegCheck   -row $aCheckRowIter -column 0 -sticky e
@@ -578,8 +584,8 @@ if { "$::tcl_platform(platform)" == "windows" } {
 }
 grid .myFrame.myChecks.myLzmaCheck     -row $aCheckRowIter -column 6 -sticky e
 grid .myFrame.myChecks.myLzmaLbl       -row $aCheckRowIter -column 7 -sticky w
-grid .myFrame.myChecks.myJDKCheck      -row $aCheckRowIter -column 10 -sticky e
+grid .myFrame.myChecks.myJDKCheck      -row $aCheckRowIter -column 12 -sticky e
-grid .myFrame.myChecks.myJDKLbl        -row $aCheckRowIter -column 11 -sticky w
+grid .myFrame.myChecks.myJDKLbl        -row $aCheckRowIter -column 13 -sticky w
 
 incr aCheckRowIter
 if { "$::tcl_platform(os)" == "Darwin" } {
@@ -588,6 +594,10 @@ if { "$::tcl_platform(os)" == "Darwin" } {
   incr aCheckRowIter
 }
 
+grid .myFrame.myChecks.myRapidJsonCheck -row $aCheckRowIter -column 6 -sticky e
+grid .myFrame.myChecks.myRapidJsonLbl   -row $aCheckRowIter -column 7 -sticky w
+incr aCheckRowIter
+
 # Additional headers search paths
 grid .myFrame.myIncLbl    -row $aRowIter -column 0 -columnspan 10 -sticky w
 incr aRowIter

adm/genconfdeps.tcl

@@ -68,7 +68,7 @@ if { [info exists ::env(SHORTCUT_HEADERS)] } {
 }
 
 # fetch environment variables (e.g. set by custom.sh or custom.bat) and set them as tcl variables with the same name
-set THE_ENV_VARIABLES {HAVE_FREEIMAGE HAVE_FFMPEG HAVE_TBB HAVE_GLES2 HAVE_D3D HAVE_VTK HAVE_ZLIB HAVE_LIBLZMA HAVE_OPENCL CHECK_QT4 CHECK_JDK MACOSX_USE_GLX HAVE_RelWithDebInfo}
+set THE_ENV_VARIABLES {HAVE_FREEIMAGE HAVE_FFMPEG HAVE_TBB HAVE_GLES2 HAVE_D3D HAVE_VTK HAVE_ZLIB HAVE_LIBLZMA HAVE_RAPIDJSON HAVE_OPENCL CHECK_QT4 CHECK_JDK MACOSX_USE_GLX HAVE_RelWithDebInfo}
 foreach anEnvIter $THE_ENV_VARIABLES {
   set ${anEnvIter} "false"
   if { [info exists ::env(${anEnvIter})] } {
@@ -858,6 +858,25 @@ proc wokdep:SearchGLES {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin6
   return "$isFound"
 }
 
+# Search RapidJSON headers
+proc wokdep:SearchRapidJson {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc anErrInc
+
+  set isFound "true"
+  set aRJHPath [wokdep:SearchHeader "rapidjson/rapidjson.h"]
+  if { "$aRJHPath"  == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{rapidjson}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/rapidjson/rapidjson.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+    } else {
+      lappend anErrInc "Error: 'rapidjson/rapidjson.h' not found (RapidJSON)"
+      set isFound "false"
+    }
+  }
+
+  return "$isFound"
+}
+
 # Auxiliary function, gets VTK version to set default search directory
 proc wokdep:VtkVersion { thePath } {
   set aResult "6.1"

adm/templates/env.bat

@@ -24,6 +24,7 @@ set "HAVE_GLES2=false"
 set "HAVE_D3D=false"
 set "HAVE_ZLIB=false"
 set "HAVE_LIBLZMA=false"
+set "HAVE_RAPIDJSON=false"
 set "CSF_OPT_INC="
 set "CSF_OPT_LIB32="
 set "CSF_OPT_LIB64="
@@ -163,6 +164,7 @@ if ["%HAVE_GLES2%"]     == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DH
 if ["%HAVE_D3D%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_D3D"       & set "CSF_DEFINES=HAVE_D3D;%CSF_DEFINES%"
 if ["%HAVE_ZLIB%"]      == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_ZLIB"      & set "CSF_DEFINES=HAVE_ZLIB;%CSF_DEFINES%"
 if ["%HAVE_LIBLZMA%"]   == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_LIBLZMA"   & set "CSF_DEFINES=HAVE_LIBLZMA;%CSF_DEFINES%"
+if ["%HAVE_RAPIDJSON%"] == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_RAPIDJSON" & set "CSF_DEFINES=HAVE_RAPIDJSON;%CSF_DEFINES%"
 
 rem Eliminate VS warning
 if ["%CSF_DEFINES%"]  == [""] set "CSF_DEFINES=;"

dox/overview/overview.md

@@ -222,6 +222,7 @@ for which OCCT is certified to work.
 | Freetype (for text rendering) | FreeType 2.4.11-2.7.1 https://sourceforge.net/projects/freetype/files/ |
 | FreeImage (optional, for support of common 2D graphic formats) | FreeImage 3.17.0+ https://sourceforge.net/projects/freeimage/files |
 | FFmpeg (optional, for video recording) | FFmpeg 3.1+ https://www.ffmpeg.org/download.html |
+| RapidJSON (optional, for reading glTF) | RapidJSON 1.1+ http://rapidjson.org/ |
 | Intel TBB (optional, for multithreaded algorithms) | TBB 4.x or 5.x https://www.threadingbuildingblocks.org/ |
 | VTK (for VTK Integration Services | VTK 6.1+ http://www.vtk.org/download/ |
 | Doxygen (optional for building documentation) | Doxygen 1.8.5+ https://www.stack.nl/~dimitri/doxygen/download.html |

src/Draw/Draw_BasicCommands.cxx

@@ -362,6 +362,11 @@ static Standard_Integer dversion(Draw_Interpretor& di, Standard_Integer, const c
 #else
   di << "OpenGL: desktop\n";
 #endif
+#ifdef HAVE_RAPIDJSON
+  di << "RapidJSON enabled (HAVE_RAPIDJSON)\n";
+#else
+  di << "RapidJSON disabled\n";
+#endif
 #ifdef HAVE_VTK
   di << "VTK enabled (HAVE_VTK)\n";
 #else

src/RWGltf/FILES

@@ -0,0 +1,22 @@
+RWGltf_GltfAccessor.hxx
+RWGltf_GltfAccessorCompType.hxx
+RWGltf_GltfAccessorLayout.hxx
+RWGltf_GltfArrayType.hxx
+RWGltf_GltfBufferView.hxx
+RWGltf_GltfBufferViewTarget.hxx
+RWGltf_GltfFace.hxx
+RWGltf_GltfLatePrimitiveArray.cxx
+RWGltf_GltfLatePrimitiveArray.hxx
+RWGltf_GltfPrimArrayData.hxx
+RWGltf_GltfPrimitiveMode.hxx
+RWGltf_GltfRootElement.hxx
+RWGltf_MaterialCommon.hxx
+RWGltf_MaterialMetallicRoughness.hxx
+RWGltf_CafReader.cxx
+RWGltf_CafReader.hxx
+RWGltf_GltfJsonParser.cxx
+RWGltf_GltfJsonParser.pxx
+RWGltf_PrimitiveArrayReader.cxx
+RWGltf_PrimitiveArrayReader.hxx
+RWGltf_TriangulationReader.cxx
+RWGltf_TriangulationReader.hxx

src/RWGltf/RWGltf_CafReader.cxx

@@ -0,0 +1,295 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 <RWGltf_CafReader.hxx>
+
+#include "RWGltf_GltfJsonParser.pxx"
+#include <RWGltf_TriangulationReader.hxx>
+
+#include <BRep_Builder.hxx>
+#include <BRep_Tool.hxx>
+#include <Message.hxx>
+#include <Message_Messenger.hxx>
+#include <Message_ProgressSentry.hxx>
+#include <OSD_OpenFile.hxx>
+#include <OSD_ThreadPool.hxx>
+
+#include <fstream>
+
+IMPLEMENT_STANDARD_RTTIEXT(RWGltf_CafReader, RWMesh_CafReader)
+
+//! Functor for parallel execution.
+class RWGltf_CafReader::CafReader_GltfReaderFunctor
+{
+public:
+
+  struct GltfReaderTLS
+  {
+    Handle(RWGltf_PrimitiveArrayReader) Reader;
+  };
+
+  //! Main constructor.
+  CafReader_GltfReaderFunctor (RWGltf_CafReader* myCafReader,
+                               NCollection_Vector<TopoDS_Face>& theFaceList,
+                               Message_ProgressSentry& theSentry,
+                               const OSD_ThreadPool::Launcher& theThreadPool,
+                               const TCollection_AsciiString& theErrPrefix)
+  : myCafReader (myCafReader),
+    myFaceList  (&theFaceList),
+    mySentry    (&theSentry),
+    myErrPrefix (theErrPrefix),
+    myThreadPool(theThreadPool),
+    myTlsData   (theThreadPool.LowerThreadIndex(), theThreadPool.UpperThreadIndex())
+  {
+    //
+  }
+
+  //! Execute task for a face with specified index.
+  void operator() (int theThreadIndex,
+                   int theFaceIndex) const
+  {
+    GltfReaderTLS& aTlsData = myTlsData.ChangeValue (theThreadIndex);
+    if (aTlsData.Reader.IsNull())
+    {
+      aTlsData.Reader = myCafReader->createMeshReaderContext();
+      aTlsData.Reader->SetErrorPrefix (myErrPrefix);
+      aTlsData.Reader->SetCoordinateSystemConverter (myCafReader->myCoordSysConverter);
+    }
+
+    TopLoc_Location aDummyLoc;
+    TopoDS_Face& aFace = myFaceList->ChangeValue (theFaceIndex);
+    Handle(RWGltf_GltfLatePrimitiveArray) aLateData = Handle(RWGltf_GltfLatePrimitiveArray)::DownCast (BRep_Tool::Triangulation (aFace, aDummyLoc));
+    Handle(Poly_Triangulation) aPolyData = aTlsData.Reader->Load (aLateData);
+    BRep_Builder aBuilder;
+    aBuilder.UpdateFace (aFace, aPolyData);
+
+    if (myThreadPool.HasThreads())
+    {
+      Standard_Mutex::Sentry aLock (&myMutex);
+      mySentry->Next();
+    }
+    else
+    {
+      mySentry->Next();
+    }
+  }
+
+private:
+
+  RWGltf_CafReader* myCafReader;
+  NCollection_Vector<TopoDS_Face>* myFaceList;
+  Message_ProgressSentry*   mySentry;
+  TCollection_AsciiString   myErrPrefix;
+  mutable Standard_Mutex    myMutex;
+  const OSD_ThreadPool::Launcher& myThreadPool;
+  mutable NCollection_Array1<GltfReaderTLS>
+                            myTlsData;
+
+};
+
+//================================================================
+// Function : Constructor
+// Purpose  :
+//================================================================
+RWGltf_CafReader::RWGltf_CafReader()
+: myToParallel (false)
+{
+  myCoordSysConverter.SetInputLengthUnit (1.0); // glTF defines model in meters
+  myCoordSysConverter.SetInputCoordinateSystem (RWMesh_CoordinateSystem_glTF);
+}
+
+//================================================================
+// Function : performMesh
+// Purpose  :
+//================================================================
+Standard_Boolean RWGltf_CafReader::performMesh (const TCollection_AsciiString& theFile,
+                                                const Handle(Message_ProgressIndicator)& theProgress,
+                                                const Standard_Boolean theToProbe)
+{
+  std::ifstream aFile;
+  OSD_OpenStream (aFile, theFile.ToCString(), std::ios::in | std::ios::binary);
+  if (!aFile.is_open()
+   || !aFile.good())
+  {
+    Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' is not found!", Message_Fail);
+    return false;
+  }
+
+  bool isBinaryFile = false;
+  char aGlbHeader[12] = {};
+  aFile.read (aGlbHeader, sizeof(aGlbHeader));
+  int64_t aBinBodyOffset  = 0;
+  int64_t aBinBodyLen     = 0;
+  int64_t aJsonBodyOffset = 0;
+  int64_t aJsonBodyLen    = 0;
+  if (::strncmp (aGlbHeader, "glTF", 4) == 0)
+  {
+    isBinaryFile = true;
+    const uint32_t* aVer = (const uint32_t* )(aGlbHeader + 4);
+    const uint32_t* aLen = (const uint32_t* )(aGlbHeader + 8);
+    if (*aVer == 1)
+    {
+      if (*aLen < 20)
+      {
+        Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' has broken glTF format!", Message_Fail);
+        return false;
+      }
+
+      char aHeader1[8] = {};
+      aFile.read (aHeader1, sizeof(aHeader1));
+
+      const uint32_t* aSceneLen    = (const uint32_t* )(aHeader1 + 0);
+      const uint32_t* aSceneFormat = (const uint32_t* )(aHeader1 + 4);
+      aJsonBodyOffset = 20;
+      aJsonBodyLen    = int64_t(*aSceneLen);
+
+      aBinBodyOffset = aJsonBodyOffset + aJsonBodyLen;
+      aBinBodyLen    = int64_t(*aLen) - aBinBodyOffset;
+      if (*aSceneFormat != 0)
+      {
+        Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' is written using unsupported Scene format!", Message_Fail);
+        return false;
+      }
+    }
+    else //if (*aVer == 2)
+    {
+      if (*aVer != 2)
+      {
+        Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' is written using unknown version " + int(*aVer) + "!", Message_Warning);
+      }
+
+      for (int aChunkIter = 0; !aFile.eof() && aChunkIter < 2; ++aChunkIter)
+      {
+        char aChunkHeader2[8] = {};
+        if (int64_t(aFile.tellg()) + int64_t(sizeof(aChunkHeader2)) > int64_t(aLen))
+        {
+          break;
+        }
+
+        aFile.read (aChunkHeader2, sizeof(aChunkHeader2));
+        if (!aFile.good())
+        {
+          Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' is written using unsupported format!", Message_Fail);
+          return false;
+        }
+
+        const uint32_t* aChunkLen  = (const uint32_t* )(aChunkHeader2 + 0);
+        const uint32_t* aChunkType = (const uint32_t* )(aChunkHeader2 + 4);
+        if (*aChunkType == 0x4E4F534A)
+        {
+          aJsonBodyOffset = int64_t(aFile.tellg());
+          aJsonBodyLen    = int64_t(*aChunkLen);
+        }
+        else if (*aChunkType == 0x004E4942)
+        {
+          aBinBodyOffset = int64_t(aFile.tellg());
+          aBinBodyLen    = int64_t(*aChunkLen);
+        }
+        if (*aChunkLen != 0)
+        {
+          aFile.seekg (*aChunkLen, std::ios_base::cur);
+        }
+      }
+
+      aFile.seekg ((std::streamoff )aJsonBodyOffset, std::ios_base::beg);
+    }
+  }
+  else
+  {
+    aFile.seekg (0, std::ios_base::beg);
+  }
+
+  TCollection_AsciiString anErrPrefix = TCollection_AsciiString ("File '") + theFile + "' defines invalid glTF!\n";
+  RWGltf_GltfJsonParser aDoc (myRootShapes);
+  aDoc.SetFilePath (theFile);
+  aDoc.SetProbeHeader (theToProbe);
+  aDoc.SetExternalFiles (myExternalFiles);
+  aDoc.SetErrorPrefix (anErrPrefix);
+  aDoc.SetCoordinateSystemConverter (myCoordSysConverter);
+  if (!theToProbe)
+  {
+    aDoc.SetAttributeMap (myAttribMap);
+  }
+  if (isBinaryFile)
+  {
+    aDoc.SetBinaryFormat (aBinBodyOffset, aBinBodyLen);
+  }
+
+#ifdef HAVE_RAPIDJSON
+  rapidjson::ParseResult aRes;
+  rapidjson::IStreamWrapper aFileStream (aFile);
+  if (isBinaryFile)
+  {
+    aRes = aDoc.ParseStream<rapidjson::kParseStopWhenDoneFlag, rapidjson::UTF8<>, rapidjson::IStreamWrapper> (aFileStream);
+  }
+  else
+  {
+    aRes = aDoc.ParseStream (aFileStream);
+  }
+  if (aRes.IsError())
+  {
+    if (aRes.Code() == rapidjson::kParseErrorDocumentEmpty)
+    {
+      Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' is empty!", Message_Fail);
+      return false;
+    }
+    TCollection_AsciiString anErrDesc (RWGltf_GltfJsonParser::FormatParseError (aRes.Code()));
+    Message::DefaultMessenger()->Send (TCollection_AsciiString ("File '") + theFile + "' defines invalid JSON document!\n"
+                                     + anErrDesc + ".", Message_Fail);
+    return false;
+  }
+#endif
+
+  if (!aDoc.Parse (theProgress))
+  {
+    return false;
+  }
+
+  if (!theToProbe
+   && !readLateData (aDoc.FaceList(), theFile, theProgress))
+  {
+    return false;
+  }
+
+  return true;
+}
+
+//================================================================
+// Function : createMeshReaderContext
+// Purpose  :
+//================================================================
+Handle(RWGltf_PrimitiveArrayReader) RWGltf_CafReader::createMeshReaderContext()
+{
+  Handle(RWGltf_TriangulationReader) aReader = new RWGltf_TriangulationReader();
+  return aReader;
+}
+
+//================================================================
+// Function : readLateData
+// Purpose  :
+//================================================================
+Standard_Boolean RWGltf_CafReader::readLateData (NCollection_Vector<TopoDS_Face>& theFaces,
+                                                 const TCollection_AsciiString& theFile,
+                                                 const Handle(Message_ProgressIndicator)& theProgress)
+{
+  Message_ProgressSentry aPSentryTris (theProgress, "Loading glTF triangulation", 0, Max (1, theFaces.Size()), 1);
+  const Handle(OSD_ThreadPool)& aThreadPool = OSD_ThreadPool::DefaultPool();
+  const int aNbThreads = myToParallel ? Min (theFaces.Size(), aThreadPool->NbDefaultThreadsToLaunch()) : 1;
+  OSD_ThreadPool::Launcher aLauncher (*aThreadPool, aNbThreads);
+
+  CafReader_GltfReaderFunctor aFunctor (this, theFaces, aPSentryTris, aLauncher,
+                                        TCollection_AsciiString ("File '") + theFile + "' defines invalid glTF!\n");
+  aLauncher.Perform (theFaces.Lower(), theFaces.Upper() + 1, aFunctor);
+  return Standard_True;
+}

src/RWGltf/RWGltf_CafReader.hxx

@@ -0,0 +1,65 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_CafReader_HeaderFile
+#define _RWGltf_CafReader_HeaderFile
+
+#include <NCollection_Vector.hxx>
+#include <RWMesh_CafReader.hxx>
+#include <TopoDS_Face.hxx>
+
+class RWGltf_PrimitiveArrayReader;
+
+//! The glTF (GL Transmission Format) mesh reader into XDE document.
+class RWGltf_CafReader : public RWMesh_CafReader
+{
+  DEFINE_STANDARD_RTTIEXT(RWGltf_CafReader, RWMesh_CafReader)
+public:
+
+  //! Empty constructor.
+  Standard_EXPORT RWGltf_CafReader();
+
+  //! Return TRUE if multithreaded optimizations are allowed; FALSE by default.
+  bool ToParallel() const { return myToParallel; }
+
+  //! Setup multithreaded execution.
+  void SetParallel (bool theToParallel) { myToParallel = theToParallel; }
+
+protected:
+
+  //! Read the mesh from specified file.
+  Standard_EXPORT virtual Standard_Boolean performMesh (const TCollection_AsciiString& theFile,
+                                                        const Handle(Message_ProgressIndicator)& theProgress,
+                                                        const Standard_Boolean theToProbe) Standard_OVERRIDE;
+
+  //! Create primitive array reader context.
+  //! Can be overridden by sub-class to read triangulation into application-specific data structures instead of Poly_Triangulation.
+  //! Default implementation creates RWGltf_TriangulationReader.
+  Standard_EXPORT virtual Handle(RWGltf_PrimitiveArrayReader) createMeshReaderContext();
+
+  //! Read late data from RWGltf_GltfLatePrimitiveArray stored as Poly_Triangulation within faces.
+  Standard_EXPORT virtual Standard_Boolean readLateData (NCollection_Vector<TopoDS_Face>& theFaces,
+                                                         const TCollection_AsciiString& theFile,
+                                                         const Handle(Message_ProgressIndicator)& theProgress);
+protected:
+
+  class CafReader_GltfReaderFunctor;
+
+protected:
+
+  Standard_Boolean myToParallel; //!< flag to use multithreading; FALSE by default
+
+};
+
+#endif // _RWGltf_CafReader_HeaderFile

src/RWGltf/RWGltf_GltfAccessor.hxx

@@ -0,0 +1,48 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfAccessor_HeaderFile
+#define _RWGltf_GltfAccessor_HeaderFile
+
+#include <Graphic3d_BndBox3d.hxx>
+#include <RWGltf_GltfAccessorCompType.hxx>
+#include <RWGltf_GltfAccessorLayout.hxx>
+#include <Standard_TypeDef.hxx>
+
+//! Low-level glTF data structure defining Accessor.
+struct RWGltf_GltfAccessor
+{
+  static const int INVALID_ID = -1;
+public:
+
+  int                         Id;            //!< identifier
+  int64_t                     ByteOffset;    //!< byte offset
+  int64_t                     Count;         //!< size
+  int32_t                     ByteStride;    //!< [0, 255] for glTF 1.0
+  RWGltf_GltfAccessorLayout   Type;          //!< layout type
+  RWGltf_GltfAccessorCompType ComponentType; //!< component type
+  Graphic3d_BndBox3d          BndBox;        //!< bounding box
+
+  //! Empty constructor.
+  RWGltf_GltfAccessor()
+  : Id (INVALID_ID),
+    ByteOffset (0),
+    Count (0),
+    ByteStride (0),
+    Type (RWGltf_GltfAccessorLayout_UNKNOWN),
+    ComponentType (RWGltf_GltfAccessorCompType_UNKNOWN) {}
+
+};
+
+#endif // _RWGltf_GltfAccessor_HeaderFile

src/RWGltf/RWGltf_GltfAccessorCompType.hxx

@@ -0,0 +1,30 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfAccessorCompType_HeaderFile
+#define _RWGltf_GltfAccessorCompType_HeaderFile
+
+//! Low-level glTF enumeration defining Accessor component type.
+enum RWGltf_GltfAccessorCompType
+{
+  RWGltf_GltfAccessorCompType_UNKNOWN, //!< unknown or invalid type
+  RWGltf_GltfAccessorCompType_Int8    = 5120, //!< GL_BYTE
+  RWGltf_GltfAccessorCompType_UInt8   = 5121, //!< GL_UNSIGNED_BYTE
+  RWGltf_GltfAccessorCompType_Int16   = 5122, //!< GL_SHORT
+  RWGltf_GltfAccessorCompType_UInt16  = 5123, //!< GL_UNSIGNED_SHORT
+  RWGltf_GltfAccessorCompType_UInt32  = 5125, //!< GL_UNSIGNED_INT
+  RWGltf_GltfAccessorCompType_Float32 = 5126, //!< GL_FLOAT
+};
+
+#endif // _RWGltf_GltfAccessorCompType_HeaderFile

src/RWGltf/RWGltf_GltfAccessorLayout.hxx

@@ -0,0 +1,68 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfAccessorLayout_HeaderFile
+#define _RWGltf_GltfAccessorLayout_HeaderFile
+
+#include <Standard_CString.hxx>
+
+//! Low-level glTF enumeration defining Accessor layout.
+//! Similar to Graphic3d_TypeOfData but does not define actual type and includes matrices.
+enum RWGltf_GltfAccessorLayout
+{
+  RWGltf_GltfAccessorLayout_UNKNOWN, //!< unknown or invalid type
+  RWGltf_GltfAccessorLayout_Scalar,  //!< "SCALAR"
+  RWGltf_GltfAccessorLayout_Vec2,    //!< "VEC2"
+  RWGltf_GltfAccessorLayout_Vec3,    //!< "VEC3"
+  RWGltf_GltfAccessorLayout_Vec4,    //!< "VEC4"
+  RWGltf_GltfAccessorLayout_Mat2,    //!< "MAT2"
+  RWGltf_GltfAccessorLayout_Mat3,    //!< "MAT3"
+  RWGltf_GltfAccessorLayout_Mat4,    //!< "MAT4"
+};
+
+//! Parse GltfAccessorLayout from string.
+inline RWGltf_GltfAccessorLayout RWGltf_GltfParseAccessorType (const char* theType)
+{
+  if (IsEqual ("SCALAR", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Scalar;
+  }
+  else if (IsEqual ("VEC2", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Vec2;
+  }
+  else if (IsEqual ("VEC3", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Vec3;
+  }
+  else if (IsEqual ("VEC4", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Vec4;
+  }
+  else if (IsEqual ("MAT2", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Mat2;
+  }
+  else if (IsEqual ("MAT3", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Mat3;
+  }
+  else if (IsEqual ("MAT4", theType))
+  {
+    return RWGltf_GltfAccessorLayout_Mat4;
+  }
+  return RWGltf_GltfAccessorLayout_UNKNOWN;
+}
+
+#endif // _RWGltf_GltfAccessorLayout_HeaderFile

src/RWGltf/RWGltf_GltfArrayType.hxx

@@ -0,0 +1,68 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfArrayType_HeaderFile
+#define _RWGltf_GltfArrayType_HeaderFile
+
+#include <Standard_CString.hxx>
+
+//! Low-level glTF enumeration defining Array type.
+enum RWGltf_GltfArrayType
+{
+  RWGltf_GltfArrayType_UNKNOWN,  //!< unknown or invalid type
+  RWGltf_GltfArrayType_Indices,  //!< "indices"    within "primitive"  element
+  RWGltf_GltfArrayType_Position, //!< "POSITION"   within "attributes" element
+  RWGltf_GltfArrayType_Normal,   //!< "NORMAL"     within "attributes" element
+  RWGltf_GltfArrayType_Color,    //!< "COLOR"      within "attributes" element
+  RWGltf_GltfArrayType_TCoord0,  //!< "TEXCOORD_0" within "attributes" element
+  RWGltf_GltfArrayType_TCoord1,  //!< "TEXCOORD_1" within "attributes" element
+  RWGltf_GltfArrayType_Joint,    //!< "JOINT"      within "attributes" element
+  RWGltf_GltfArrayType_Weight,   //!< "WEIGHT"     within "attributes" element
+};
+
+//! Parse GltfArrayType from string.
+inline RWGltf_GltfArrayType RWGltf_GltfParseAttribType (const char* theType)
+{
+  if (IsEqual ("POSITION", theType))
+  {
+    return RWGltf_GltfArrayType_Position;
+  }
+  else if (IsEqual ("NORMAL", theType))
+  {
+    return RWGltf_GltfArrayType_Normal;
+  }
+  else if (IsEqual ("COLOR", theType))
+  {
+    return RWGltf_GltfArrayType_Color;
+  }
+  else if (IsEqual ("TEXCOORD_0", theType))
+  {
+    return RWGltf_GltfArrayType_TCoord0;
+  }
+  else if (IsEqual ("TEXCOORD_1", theType))
+  {
+    return RWGltf_GltfArrayType_TCoord1;
+  }
+  else if (IsEqual ("JOINT", theType))
+  {
+    return RWGltf_GltfArrayType_Joint;
+  }
+  else if (IsEqual ("WEIGHT", theType))
+  {
+    return RWGltf_GltfArrayType_Weight;
+  }
+  return RWGltf_GltfArrayType_UNKNOWN;
+}
+
+#endif // _RWGltf_GltfArrayType_HeaderFile

src/RWGltf/RWGltf_GltfBufferView.hxx

@@ -0,0 +1,38 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfBufferView_HeaderFile
+#define _RWGltf_GltfBufferView_HeaderFile
+
+#include <RWGltf_GltfBufferViewTarget.hxx>
+#include <Standard_TypeDef.hxx>
+
+//! Low-level glTF data structure defining BufferView.
+struct RWGltf_GltfBufferView
+{
+  static const int INVALID_ID = -1;
+public:
+
+  int                         Id;
+  int64_t                     ByteOffset;
+  int64_t                     ByteLength;
+  int32_t                     ByteStride; //!< [0, 255]
+  RWGltf_GltfBufferViewTarget Target;
+
+  RWGltf_GltfBufferView()
+  : Id (INVALID_ID), ByteOffset (0), ByteLength (0), ByteStride (0), Target (RWGltf_GltfBufferViewTarget_UNKNOWN) {}
+
+};
+
+#endif // _RWGltf_GltfBufferView_HeaderFile

src/RWGltf/RWGltf_GltfBufferViewTarget.hxx

@@ -0,0 +1,26 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfBufferViewTarget_HeaderFile
+#define _RWGltf_GltfBufferViewTarget_HeaderFile
+
+//! Low-level glTF enumeration defining BufferView target.
+enum RWGltf_GltfBufferViewTarget
+{
+  RWGltf_GltfBufferViewTarget_UNKNOWN,                      //!< unknown or invalid type
+  RWGltf_GltfBufferViewTarget_ARRAY_BUFFER         = 34962, //!< GL_ARRAY_BUFFER
+  RWGltf_GltfBufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963, //!< GL_ELEMENT_ARRAY_BUFFER
+};
+
+#endif // _RWGltf_GltfBufferViewTarget_HeaderFile

src/RWGltf/RWGltf_GltfFace.hxx

@@ -0,0 +1,29 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfFace_HeaderFile
+#define _RWGltf_GltfFace_HeaderFile
+
+#include <RWGltf_GltfAccessor.hxx>
+
+//! Low-level glTF data structure holding single Face (one primitive array) definition.
+struct RWGltf_GltfFace
+{
+  RWGltf_GltfAccessor NodePos;  //!< accessor for nodal positions
+  RWGltf_GltfAccessor NodeNorm; //!< accessor for nodal normals
+  RWGltf_GltfAccessor NodeUV;   //!< accessor for nodal UV texture coordinates
+  RWGltf_GltfAccessor Indices;  //!< accessor for indexes
+};
+
+#endif // _RWGltf_GltfFace_HeaderFile

src/RWGltf/RWGltf_GltfJsonParser.pxx

@@ -0,0 +1,416 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfJsonParser_HeaderFile
+#define _RWGltf_GltfJsonParser_HeaderFile
+
+#include <Graphic3d_Vec.hxx>
+#include <Message_Gravity.hxx>
+#include <NCollection_DataMap.hxx>
+#include <NCollection_IndexedMap.hxx>
+#include <RWGltf_GltfLatePrimitiveArray.hxx>
+#include <RWGltf_GltfBufferView.hxx>
+#include <RWGltf_GltfRootElement.hxx>
+#include <RWGltf_MaterialCommon.hxx>
+#include <RWGltf_MaterialMetallicRoughness.hxx>
+#include <RWMesh_CoordinateSystemConverter.hxx>
+#include <RWMesh_NodeAttributes.hxx>
+#include <TColStd_IndexedDataMapOfStringString.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopTools_SequenceOfShape.hxx>
+
+// workaround name collisions with XLib
+#ifdef None
+  #undef None
+#endif
+#ifdef Bool
+  #undef Bool
+#endif
+
+#ifdef HAVE_RAPIDJSON
+  //#define RAPIDJSON_ASSERT
+  #include <rapidjson/document.h>
+  #include <rapidjson/prettywriter.h>
+  #include <rapidjson/stringbuffer.h>
+  #include <rapidjson/istreamwrapper.h>
+  #include <rapidjson/ostreamwrapper.h>
+
+  typedef rapidjson::Document::ValueType RWGltf_JsonValue;
+#endif
+
+class Message_ProgressIndicator;
+
+//! INTERNAL tool for parsing glTF document (JSON structure).
+class RWGltf_GltfJsonParser
+#ifdef HAVE_RAPIDJSON
+: public rapidjson::Document
+#endif
+{
+public:
+
+#ifdef HAVE_RAPIDJSON
+  //! Auxiliary method for formatting error code.
+  Standard_EXPORT static const char* FormatParseError (rapidjson::ParseErrorCode theCode);
+#endif
+
+public:
+
+  //! Empty constructor.
+  Standard_EXPORT RWGltf_GltfJsonParser (TopTools_SequenceOfShape& theRootShapes);
+
+  //! Set file path.
+  Standard_EXPORT void SetFilePath (const TCollection_AsciiString& theFilePath);
+
+  //! Set flag for probing file without complete reading.
+  void SetProbeHeader (bool theToProbe) { myToProbeHeader = theToProbe; }
+
+  //! Return prefix for reporting issues.
+  const TCollection_AsciiString& ErrorPrefix() const { return myErrorPrefix; }
+
+  //! Set prefix for reporting issues.
+  void SetErrorPrefix (const TCollection_AsciiString& theErrPrefix) { myErrorPrefix = theErrPrefix; }
+
+  //! Set map for storing node attributes.
+  void SetAttributeMap (RWMesh_NodeAttributeMap& theAttribMap) { myAttribMap = &theAttribMap; }
+
+  //! Set list for storing external files.
+  void SetExternalFiles (NCollection_IndexedMap<TCollection_AsciiString>& theExternalFiles) { myExternalFiles = &theExternalFiles; }
+
+  //! Return transformation from glTF to OCCT coordinate system.
+  const RWMesh_CoordinateSystemConverter& CoordinateSystemConverter() const { return myCSTrsf; }
+
+  //! Set transformation from glTF to OCCT coordinate system.
+  void SetCoordinateSystemConverter (const RWMesh_CoordinateSystemConverter& theConverter) { myCSTrsf = theConverter; }
+
+  //! Initialize binary format.
+  void SetBinaryFormat (int64_t theBinBodyOffset,
+                        int64_t theBinBodyLen)
+  {
+    myIsBinary      = true;
+    myBinBodyOffset = theBinBodyOffset;
+    myBinBodyLen    = theBinBodyLen;
+  }
+
+  //! Parse glTF document.
+  Standard_EXPORT bool Parse (const Handle(Message_ProgressIndicator)& theProgress);
+
+  //! Return metadata map.
+  const TColStd_IndexedDataMapOfStringString& Metadata() const { return myMetadata; }
+
+  //! Return face list for loading triangulation.
+  NCollection_Vector<TopoDS_Face>& FaceList() { return myFaceList; }
+
+protected:
+#ifdef HAVE_RAPIDJSON
+  //! Search mandatory root elements in the document.
+  //! Return FALSE if some mandatory element is missing.
+  Standard_EXPORT bool gltfParseRoots();
+
+  //! Parse default scene.
+  Standard_EXPORT bool gltfParseScene (const Handle(Message_ProgressIndicator)& theProgress);
+
+  //! Parse document metadata.
+  Standard_EXPORT void gltfParseAsset();
+
+protected:
+
+  //! Parse materials defined in the document.
+  Standard_EXPORT void gltfParseMaterials();
+
+  //! Parse standard material.
+  Standard_EXPORT bool gltfParseStdMaterial (Handle(RWGltf_MaterialCommon)& theMat,
+                                             const RWGltf_JsonValue& theMatNode);
+
+  //! Parse pbrMetallicRoughness material.
+  Standard_EXPORT bool gltfParsePbrMaterial (Handle(RWGltf_MaterialMetallicRoughness)& theMat,
+                                             const RWGltf_JsonValue& theMatNode);
+
+  //! Parse common material (KHR_materials_common extension).
+  Standard_EXPORT bool gltfParseCommonMaterial (Handle(RWGltf_MaterialCommon)& theMat,
+                                                const RWGltf_JsonValue& theMatNode);
+
+  //! Parse texture definition.
+  Standard_EXPORT bool gltfParseTexture (Handle(Image_Texture)& theTexture,
+                                         const RWGltf_JsonValue* theTextureId);
+
+protected:
+
+  //! Parse scene array of nodes recursively.
+  Standard_EXPORT bool gltfParseSceneNodes (TopTools_SequenceOfShape& theShapeSeq,
+                                            const RWGltf_JsonValue& theSceneNodes,
+                                            const Handle(Message_ProgressIndicator)& theProgress);
+
+  //! Parse scene node recursively.
+  Standard_EXPORT bool gltfParseSceneNode (TopoDS_Shape& theNodeShape,
+                                           const TCollection_AsciiString& theSceneNodeId,
+                                           const RWGltf_JsonValue& theSceneNode,
+                                           const Handle(Message_ProgressIndicator)& theProgress);
+
+  //! Parse mesh element.
+  Standard_EXPORT bool gltfParseMesh (TopoDS_Shape& theMeshShape,
+                                      const TCollection_AsciiString& theMeshId,
+                                      const RWGltf_JsonValue& theMesh,
+                                      const Handle(Message_ProgressIndicator)& theProgress);
+
+  //! Parse primitive array.
+  Standard_EXPORT bool gltfParsePrimArray (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
+                                           const TCollection_AsciiString& theMeshName,
+                                           const RWGltf_JsonValue& thePrimArray,
+                                           const Handle(Message_ProgressIndicator)& theProgress);
+
+  //! Parse accessor.
+  Standard_EXPORT bool gltfParseAccessor (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
+                                          const TCollection_AsciiString& theName,
+                                          const RWGltf_JsonValue& theAccessor,
+                                          const RWGltf_GltfArrayType theType);
+
+  //! Parse buffer view.
+  Standard_EXPORT bool gltfParseBufferView (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
+                                            const TCollection_AsciiString& theName,
+                                            const RWGltf_JsonValue& theBufferView,
+                                            const RWGltf_GltfAccessor& theAccessor,
+                                            const RWGltf_GltfArrayType theType);
+
+  //! Parse buffer.
+  Standard_EXPORT bool gltfParseBuffer (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
+                                        const TCollection_AsciiString& theName,
+                                        const RWGltf_JsonValue& theBuffer,
+                                        const RWGltf_GltfAccessor&   theAccessor,
+                                        const RWGltf_GltfBufferView& theView,
+                                        const RWGltf_GltfArrayType   theType);
+
+protected:
+
+  //! Read vec4 from specified item.
+  static bool gltfReadVec4 (Graphic3d_Vec4d& theVec4,
+                            const RWGltf_JsonValue* theVal)
+  {
+    if (theVal == NULL
+    || !theVal->IsArray()
+    ||  theVal->Size() != 4)
+    {
+      return false;
+    }
+
+    for (int aCompIter = 0; aCompIter < 4; ++aCompIter)
+    {
+      const RWGltf_JsonValue& aGenVal = (*theVal)[aCompIter];
+      if (!aGenVal.IsNumber())
+      {
+        return false;
+      }
+      theVec4[aCompIter] = aGenVal.GetDouble();
+    }
+    return true;
+  }
+
+  //! Validate color
+  static bool validateColor4 (const Graphic3d_Vec4d& theVec)
+  {
+    return theVec.r() >= 0.0 && theVec.r() <= 1.0
+        && theVec.g() >= 0.0 && theVec.g() <= 1.0
+        && theVec.b() >= 0.0 && theVec.b() <= 1.0
+        && theVec.a() >= 0.0 && theVec.a() <= 1.0;
+  }
+
+  //! Read vec3 from specified item.
+  static bool gltfReadVec3 (Graphic3d_Vec3d& theVec3,
+                            const RWGltf_JsonValue* theVal)
+  {
+    if (theVal == NULL
+    || !theVal->IsArray()
+    ||  theVal->Size() != 3)
+    {
+      return false;
+    }
+
+    for (int aCompIter = 0; aCompIter < 3; ++aCompIter)
+    {
+      const RWGltf_JsonValue& aGenVal = (*theVal)[aCompIter];
+      if (!aGenVal.IsNumber())
+      {
+        return false;
+      }
+      theVec3[aCompIter] = aGenVal.GetDouble();
+    }
+    return true;
+  }
+
+  //! Validate color
+  static bool validateColor3 (const Graphic3d_Vec3d& theVec)
+  {
+    return theVec.r() >= 0.0 && theVec.r() <= 1.0
+        && theVec.g() >= 0.0 && theVec.g() <= 1.0
+        && theVec.b() >= 0.0 && theVec.b() <= 1.0;
+  }
+
+protected:
+
+  //! Groups for re-using shapes.
+  enum ShapeMapGroup
+  {
+    ShapeMapGroup_Nodes,  //!< nodes
+    ShapeMapGroup_Meshes, //!< meshes
+  };
+
+  //! Bind name attribute.
+  void bindNodeShape (TopoDS_Shape& theShape,
+                      const TopLoc_Location& theLoc,
+                      const TCollection_AsciiString& theNodeId,
+                      const RWGltf_JsonValue* theUserName)
+  {
+    bindNamedShape (theShape, ShapeMapGroup_Nodes, theLoc, theNodeId, theUserName);
+  }
+
+  //! Bind name attribute.
+  void bindMeshShape (TopoDS_Shape& theShape,
+                      const TCollection_AsciiString& theMeshId,
+                      const RWGltf_JsonValue* theUserName)
+  {
+    bindNamedShape (theShape, ShapeMapGroup_Meshes, TopLoc_Location(), theMeshId, theUserName);
+  }
+
+  //! Find named shape.
+  bool findNodeShape (TopoDS_Shape& theShape,
+                      const TCollection_AsciiString& theNodeId) const
+  {
+    return findNamedShape (theShape, ShapeMapGroup_Nodes, theNodeId);
+  }
+
+  //! Find named shape.
+  bool findMeshShape (TopoDS_Shape& theShape,
+                      const TCollection_AsciiString& theMeshId) const
+  {
+    return findNamedShape (theShape, ShapeMapGroup_Meshes, theMeshId);
+  }
+
+  //! Bind name attribute.
+  Standard_EXPORT void bindNamedShape (TopoDS_Shape& theShape,
+                                       ShapeMapGroup theGroup,
+                                       const TopLoc_Location& theLoc,
+                                       const TCollection_AsciiString& theId,
+                                       const RWGltf_JsonValue* theUserName);
+
+  //! Find named shape.
+  bool findNamedShape (TopoDS_Shape& theShape,
+                       ShapeMapGroup theGroup,
+                       const TCollection_AsciiString& theId) const
+  {
+    return myShapeMap[theGroup].Find (theId, theShape);
+  }
+
+  //! Return the string representation of the key.
+  static TCollection_AsciiString getKeyString (const RWGltf_JsonValue& theValue)
+  {
+    if (theValue.IsString())
+    {
+      return TCollection_AsciiString (theValue.GetString());
+    }
+    else if (theValue.IsInt())
+    {
+      return TCollection_AsciiString (theValue.GetInt());
+    }
+    return TCollection_AsciiString();
+  }
+
+protected:
+
+  //! Auxiliary structure for fast look-up of document sub-nodes of specified node.
+  class GltfElementMap
+  {
+  public:
+
+    //! Empty constructor.
+    GltfElementMap() : myRoot (NULL) {}
+
+    //! Return TRUE if this element is NULL.
+    bool IsNull() const { return myRoot == NULL; }
+
+    //! Access this node.
+    const RWGltf_JsonValue* Root() const { return myRoot; }
+
+    //! Find the child node with specified key.
+    const RWGltf_JsonValue* FindChild (const TCollection_AsciiString& theKey)
+    {
+      const RWGltf_JsonValue* aNode = NULL;
+      return myChildren.Find (theKey, aNode)
+           ? aNode
+           : NULL;
+    }
+
+    //! Find the child node with specified key.
+    const RWGltf_JsonValue* FindChild (const RWGltf_JsonValue& theKey)
+    {
+      const TCollection_AsciiString aKey = getKeyString (theKey);
+      if (aKey.IsEmpty())
+      {
+        return NULL;
+      }
+
+      const RWGltf_JsonValue* aNode = NULL;
+      return myChildren.Find (aKey, aNode)
+           ? aNode
+           : NULL;
+    }
+
+    //! Initialize the element.
+    void Init (const TCollection_AsciiString& theRootName,
+               const RWGltf_JsonValue* theRoot);
+
+  private:
+
+    NCollection_DataMap<TCollection_AsciiString, const RWGltf_JsonValue*, TCollection_AsciiString> myChildren;
+    const RWGltf_JsonValue* myRoot;
+
+  };
+#endif
+protected:
+
+  //! Print message about invalid glTF syntax.
+  void reportGltfSyntaxProblem (const TCollection_AsciiString& theMsg, Message_Gravity theGravity);
+
+protected:
+
+  TopTools_SequenceOfShape*        myRootShapes;    //!< sequence of result root shapes
+  RWMesh_NodeAttributeMap*         myAttribMap;     //!< shape attributes
+  NCollection_IndexedMap<TCollection_AsciiString>*
+                                   myExternalFiles; //!< list of external file references
+  RWMesh_CoordinateSystemConverter myCSTrsf;        //!< transformation from glTF to OCCT coordinate system
+
+  TColStd_IndexedDataMapOfStringString myMetadata; //!< file metadata
+  NCollection_DataMap<TCollection_AsciiString, Handle(RWGltf_MaterialMetallicRoughness)> myMaterialsPbr;
+  NCollection_DataMap<TCollection_AsciiString, Handle(RWGltf_MaterialCommon)> myMaterialsCommon;
+  NCollection_DataMap<TCollection_AsciiString, TopoDS_Shape> myShapeMap[2];
+
+  NCollection_DataMap<TCollection_AsciiString, bool> myProbedFiles;
+  NCollection_DataMap<TCollection_AsciiString, Handle(NCollection_Buffer)> myDecodedBuffers;
+  NCollection_Vector<TopoDS_Face> myFaceList; //!< face list for loading triangulation
+
+  TCollection_AsciiString   myFilePath;       //!< file path
+  TCollection_AsciiString   myFolder;         //!< folder
+  TCollection_AsciiString   myErrorPrefix;    //!< invalid syntax error prefix
+  int64_t                   myBinBodyOffset;  //!< offset to binary body
+  int64_t                   myBinBodyLen;     //!< binary body length
+  bool                      myIsBinary;       //!< binary document
+  bool                      myIsGltf1;        //!< obsolete glTF 1.0 version format
+  bool                      myToSkipEmptyNodes; //!< ignore nodes without Geometry
+  bool                      myToProbeHeader;  //!< flag to probe header without full reading, FALSE by default
+
+#ifdef HAVE_RAPIDJSON
+  GltfElementMap myGltfRoots[RWGltf_GltfRootElement_NB]; //!< glTF format root elements
+#endif
+
+};
+
+#endif // _RWGltf_GltfJsonParser_HeaderFile

src/RWGltf/RWGltf_GltfLatePrimitiveArray.cxx

@@ -0,0 +1,133 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2018-2019 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 <RWGltf_GltfLatePrimitiveArray.hxx>
+
+#include <RWGltf_MaterialMetallicRoughness.hxx>
+#include <RWGltf_MaterialCommon.hxx>
+
+#include <Message.hxx>
+#include <Message_Messenger.hxx>
+#include <OSD_OpenFile.hxx>
+#include <Standard_ArrayStreamBuffer.hxx>
+
+#include <fstream>
+
+IMPLEMENT_STANDARD_RTTIEXT(RWGltf_GltfLatePrimitiveArray, Poly_Triangulation)
+
+// =======================================================================
+// function : RWGltf_GltfLatePrimitiveArray
+// purpose  :
+// =======================================================================
+RWGltf_GltfLatePrimitiveArray::RWGltf_GltfLatePrimitiveArray (const TCollection_AsciiString& theId,
+                                                              const TCollection_AsciiString& theName)
+: Poly_Triangulation (3, 1, false),
+  myId (theId),
+  myName (theName),
+  myPrimMode (RWGltf_GltfPrimitiveMode_UNKNOWN)
+{
+  SetBoundingBox (Bnd_Box());
+}
+
+// =======================================================================
+// function : ~RWGltf_GltfLatePrimitiveArray
+// purpose  :
+// =======================================================================
+RWGltf_GltfLatePrimitiveArray::~RWGltf_GltfLatePrimitiveArray()
+{
+  //
+}
+
+// =======================================================================
+// function : BaseColor
+// purpose  :
+// =======================================================================
+Quantity_ColorRGBA RWGltf_GltfLatePrimitiveArray::BaseColor() const
+{
+  if (!myMaterialPbr.IsNull())
+  {
+    return myMaterialPbr->BaseColor;
+  }
+  else if (!myMaterialCommon.IsNull())
+  {
+    return Quantity_ColorRGBA (myMaterialCommon->DiffuseColor, 1.0f - myMaterialCommon->Transparency);
+  }
+  return Quantity_ColorRGBA();
+}
+
+// =======================================================================
+// function : AddPrimArrayData
+// purpose  :
+// =======================================================================
+RWGltf_GltfPrimArrayData& RWGltf_GltfLatePrimitiveArray::AddPrimArrayData (RWGltf_GltfArrayType theType)
+{
+  if (theType == RWGltf_GltfArrayType_Position)
+  {
+    // make sure positions go first
+    myData.Prepend (RWGltf_GltfPrimArrayData (theType));
+    return myData.ChangeFirst();
+  }
+  else if (theType == RWGltf_GltfArrayType_Indices)
+  {
+    // make sure indexes go after vertex positions but before any other vertex attributes
+    if (myData.First().Type == RWGltf_GltfArrayType_Position)
+    {
+      myData.InsertAfter (myData.Lower(), RWGltf_GltfPrimArrayData (theType));
+      return myData.ChangeValue (myData.Lower() + 1);
+    }
+    else
+    {
+      myData.Prepend (RWGltf_GltfPrimArrayData (theType));
+      return myData.ChangeFirst();
+    }
+  }
+  else
+  {
+    myData.Append (RWGltf_GltfPrimArrayData (theType));
+    return myData.ChangeLast();
+  }
+}
+
+// =======================================================================
+// function : SetBoundingBox
+// purpose  :
+// =======================================================================
+void RWGltf_GltfLatePrimitiveArray::SetBoundingBox (const Bnd_Box& theBox)
+{
+  myBox = theBox;
+
+  if (theBox.IsVoid())
+  {
+    Poly_Triangulation::myNodes = TColgp_Array1OfPnt();
+    Poly_Triangulation::myTriangles = Poly_Array1OfTriangle();
+    return;
+  }
+
+  // define 8 nodes so that AABB will be huge enough to include mesh even with transformation applied
+  Poly_Triangulation::myNodes.Resize (1, 8, false);
+  const gp_Pnt aMin = theBox.CornerMin();
+  const gp_Pnt aMax = theBox.CornerMax();
+  Poly_Triangulation::ChangeNode(1).SetCoord(aMin.X(), aMin.Y(), aMin.Z());
+  Poly_Triangulation::ChangeNode(2).SetCoord(aMax.X(), aMax.Y(), aMax.Z());
+  Poly_Triangulation::ChangeNode(3).SetCoord(aMin.X(), aMin.Y(), aMax.Z());
+  Poly_Triangulation::ChangeNode(4).SetCoord(aMin.X(), aMax.Y(), aMax.Z());
+  Poly_Triangulation::ChangeNode(5).SetCoord(aMax.X(), aMax.Y(), aMin.Z());
+  Poly_Triangulation::ChangeNode(6).SetCoord(aMax.X(), aMin.Y(), aMin.Z());
+  Poly_Triangulation::ChangeNode(7).SetCoord(aMin.X(), aMax.Y(), aMin.Z());
+  Poly_Triangulation::ChangeNode(8).SetCoord(aMax.X(), aMin.Y(), aMax.Z());
+
+  Poly_Triangulation::myTriangles.Resize (1, 1, false);
+  Poly_Triangulation::ChangeTriangle (1).Set (1, 2, 1);
+  //Poly_Triangulation::myTriangles = Poly_Array1OfTriangle();
+}

src/RWGltf/RWGltf_GltfLatePrimitiveArray.hxx

@@ -0,0 +1,99 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2018-2019 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 _RWGltf_GltfLatePrimitiveArray_HeaderFile
+#define _RWGltf_GltfLatePrimitiveArray_HeaderFile
+
+#include <Bnd_Box.hxx>
+#include <NCollection_Sequence.hxx>
+#include <Poly_Triangulation.hxx>
+#include <RWGltf_GltfPrimArrayData.hxx>
+#include <RWGltf_GltfPrimitiveMode.hxx>
+#include <Quantity_ColorRGBA.hxx>
+
+class RWGltf_MaterialMetallicRoughness;
+class RWGltf_MaterialCommon;
+
+//! Mesh data wrapper for delayed primitive array loading from glTF file.
+//! Class inherits Poly_Triangulation so that it can be put temporarily into TopoDS_Face within assembly structure,
+//! to be replaced with proper Poly_Triangulation loaded later on.
+class RWGltf_GltfLatePrimitiveArray : public Poly_Triangulation
+{
+  DEFINE_STANDARD_RTTIEXT(RWGltf_GltfLatePrimitiveArray, Poly_Triangulation)
+public:
+
+  //! Constructor.
+  Standard_EXPORT RWGltf_GltfLatePrimitiveArray (const TCollection_AsciiString& theId,
+                                                 const TCollection_AsciiString& theName);
+
+  //! Destructor.
+  Standard_EXPORT virtual ~RWGltf_GltfLatePrimitiveArray();
+
+  //! Entity id.
+  const TCollection_AsciiString& Id() const { return myId; }
+
+  //! Entity name.
+  const TCollection_AsciiString& Name() const { return myName; }
+
+  //! Assign entity name.
+  void SetName (const TCollection_AsciiString& theName) { myName = theName; }
+
+  //! Return type of primitive array.
+  RWGltf_GltfPrimitiveMode PrimitiveMode() const { return myPrimMode; }
+
+  //! Set type of primitive array.
+  void SetPrimitiveMode (RWGltf_GltfPrimitiveMode theMode) { myPrimMode = theMode; }
+
+  //! Return true if primitive array has assigned material
+  bool HasStyle() const { return !myMaterialPbr.IsNull() || !myMaterialCommon.IsNull(); }
+
+  //! Return base color.
+  Standard_EXPORT Quantity_ColorRGBA BaseColor() const;
+
+  //! Return PBR material definition.
+  const Handle(RWGltf_MaterialMetallicRoughness)& MaterialPbr() const { return myMaterialPbr; }
+
+  //! Set PBR material definition.
+  void SetMaterialPbr (const Handle(RWGltf_MaterialMetallicRoughness)& theMat) { myMaterialPbr = theMat; }
+
+  //! Return common (obsolete) material definition.
+  const Handle(RWGltf_MaterialCommon)& MaterialCommon() const { return myMaterialCommon; }
+
+  //! Set common (obsolete) material definition.
+  void SetMaterialCommon (const Handle(RWGltf_MaterialCommon)& theMat) { myMaterialCommon = theMat; }
+
+  //! Return primitive array data elements.
+  const NCollection_Sequence<RWGltf_GltfPrimArrayData>& Data() const { return myData; }
+
+  //! Add primitive array data element.
+  Standard_EXPORT RWGltf_GltfPrimArrayData& AddPrimArrayData (RWGltf_GltfArrayType theType);
+
+  //! This method sets input bounding box and assigns a FAKE data to underlying Poly_Triangulation
+  //! as Min/Max corners of bounding box, so that standard tools like BRepBndLib::Add()
+  //! can be used transparently for computing bounding box of this face.
+  Standard_EXPORT void SetBoundingBox (const Bnd_Box& theBox);
+
+private:
+
+  NCollection_Sequence<RWGltf_GltfPrimArrayData> myData;
+  Handle(RWGltf_MaterialMetallicRoughness) myMaterialPbr;    //!< PBR material
+  Handle(RWGltf_MaterialCommon)            myMaterialCommon; //!< common (obsolete) material
+  Bnd_Box                  myBox;        //!< bounding box
+  TCollection_AsciiString  myId;         //!< entity id
+  TCollection_AsciiString  myName;       //!< entity name
+  RWGltf_GltfPrimitiveMode myPrimMode;   //!< type of primitive array
+
+};
+
+#endif // _RWGltf_GltfLatePrimitiveArray_HeaderFile

src/RWGltf/RWGltf_GltfPrimArrayData.hxx

@@ -0,0 +1,41 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2018-2019 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 _RWGltf_GltfPrimArrayData_HeaderFile
+#define _RWGltf_GltfPrimArrayData_HeaderFile
+
+#include <NCollection_Buffer.hxx>
+#include <RWGltf_GltfAccessor.hxx>
+#include <RWGltf_GltfArrayType.hxx>
+#include <TCollection_AsciiString.hxx>
+
+//! An element within primitive array - vertex attribute or element indexes.
+class RWGltf_GltfPrimArrayData
+{
+public:
+  Handle(NCollection_Buffer) StreamData;
+  TCollection_AsciiString    StreamUri;
+  int64_t                    StreamOffset;
+
+  RWGltf_GltfAccessor        Accessor;
+  RWGltf_GltfArrayType       Type;
+
+  RWGltf_GltfPrimArrayData()
+  : StreamOffset (0), Type (RWGltf_GltfArrayType_UNKNOWN) {}
+
+  RWGltf_GltfPrimArrayData (RWGltf_GltfArrayType theType)
+  : StreamOffset (0), Type (theType) {}
+};
+
+#endif // _RWGltf_GltfPrimArrayData_HeaderFile

src/RWGltf/RWGltf_GltfPrimitiveMode.hxx

@@ -0,0 +1,32 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfPrimitiveMode_HeaderFile
+#define _RWGltf_GltfPrimitiveMode_HeaderFile
+
+//! Low-level glTF enumeration defining Primitive type.
+//! Similar to Graphic3d_TypeOfData but does not define actual type and includes matrices.
+enum RWGltf_GltfPrimitiveMode
+{
+  RWGltf_GltfPrimitiveMode_UNKNOWN       = -1, //!< unknown or invalid type
+  RWGltf_GltfPrimitiveMode_Points        =  0, //!< GL_POINTS
+  RWGltf_GltfPrimitiveMode_Lines         =  1, //!< GL_LINES
+  RWGltf_GltfPrimitiveMode_LineLoop      =  2, //!< GL_LINE_LOOP
+  RWGltf_GltfPrimitiveMode_LineStrip     =  3, //!< GL_LINE_STRIP
+  RWGltf_GltfPrimitiveMode_Triangles     =  4, //!< GL_TRIANGLES
+  RWGltf_GltfPrimitiveMode_TriangleStrip =  5, //!< GL_TRIANGLE_STRIP
+  RWGltf_GltfPrimitiveMode_TriangleFan   =  6, //!< GL_TRIANGLE_FAN
+};
+
+#endif // _RWGltf_GltfPrimitiveMode_HeaderFile

src/RWGltf/RWGltf_GltfRootElement.hxx

@@ -0,0 +1,73 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_GltfRootElement_HeaderFile
+#define _RWGltf_GltfRootElement_HeaderFile
+
+//! Root elements within glTF JSON document.
+enum RWGltf_GltfRootElement
+{
+  RWGltf_GltfRootElement_Asset,        //!< "asset"       element, mandatory
+  RWGltf_GltfRootElement_Scenes,       //!< "scenes"      element, mandatory
+  RWGltf_GltfRootElement_Scene,        //!< "scene"       element, mandatory
+  RWGltf_GltfRootElement_Nodes,        //!< "nodes"       element, mandatory
+  RWGltf_GltfRootElement_Meshes,       //!< "meshes"      element, mandatory
+  RWGltf_GltfRootElement_Accessors,    //!< "accessors"   element, mandatory
+  RWGltf_GltfRootElement_BufferViews,  //!< "bufferViews" element, mandatory
+  RWGltf_GltfRootElement_Buffers,      //!< "buffers"     element, mandatory
+  RWGltf_GltfRootElement_NB_MANDATORY, //!< number of mandatory elements
+  // optional elements
+  RWGltf_GltfRootElement_Animations = RWGltf_GltfRootElement_NB_MANDATORY,  //!< "animations" element
+  RWGltf_GltfRootElement_Materials,    //!< "materials"  element,
+  RWGltf_GltfRootElement_Programs,     //!< "programs"   element,
+  RWGltf_GltfRootElement_Samplers,     //!< "samplers"   element,
+  RWGltf_GltfRootElement_Shaders,      //!< "shaders"    element,
+  RWGltf_GltfRootElement_Skins,        //!< "skins"      element,
+  RWGltf_GltfRootElement_Techniques,   //!< "techniques" element,
+  RWGltf_GltfRootElement_Textures,     //!< "textures"   element,
+  RWGltf_GltfRootElement_Images,       //!< "images"     element,
+  RWGltf_GltfRootElement_ExtensionsUsed,     //!< "extensionsUsed"     element,
+  RWGltf_GltfRootElement_ExtensionsRequired, //!< "extensionsRequired" element,
+  RWGltf_GltfRootElement_NB            //!< overall number of elements
+};
+
+//! Root elements within glTF JSON document - names array.
+inline const char* RWGltf_GltfRootElementName (RWGltf_GltfRootElement theElem)
+{
+  static const char* THE_ROOT_NAMES[RWGltf_GltfRootElement_NB] =
+  {
+    "asset",
+    "scenes",
+    "scene",
+    "nodes",
+    "meshes",
+    "accessors",
+    "bufferViews",
+    "buffers",
+    "animations",
+    "materials",
+    "programs",
+    "samplers",
+    "shaders",
+    "skins",
+    "techniques",
+    "textures",
+    "images",
+    "extensionsUsed",
+    "extensionsRequired"
+  };
+  return THE_ROOT_NAMES[theElem];
+}
+
+#endif // _RWGltf_GltfRootElement_HeaderFile

src/RWGltf/RWGltf_MaterialCommon.hxx

@@ -0,0 +1,48 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2016-2019 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 _RWGltf_MaterialCommon_HeaderFile
+#define _RWGltf_MaterialCommon_HeaderFile
+
+#include <Image_Texture.hxx>
+#include <Quantity_ColorRGBA.hxx>
+
+//! glTF 1.0 format common (obsolete) material definition.
+class RWGltf_MaterialCommon : public Standard_Transient
+{
+public:
+
+  Handle(Image_Texture)   AmbientTexture;  //!< image defining ambient color
+  Handle(Image_Texture)   DiffuseTexture;  //!< image defining diffuse color
+  Handle(Image_Texture)   SpecularTexture; //!< image defining specular color
+  TCollection_AsciiString Id;              //!< material identifier
+  TCollection_AsciiString Name;            //!< material name
+  Quantity_Color          AmbientColor;
+  Quantity_Color          DiffuseColor;
+  Quantity_Color          SpecularColor;
+  Quantity_Color          EmissiveColor;
+  Standard_ShortReal      Shininess;
+  Standard_ShortReal      Transparency;
+
+  RWGltf_MaterialCommon()
+  : AmbientColor (0.1, 0.1, 0.1, Quantity_TOC_RGB),
+    DiffuseColor (0.8, 0.8, 0.8, Quantity_TOC_RGB),
+    SpecularColor(0.2, 0.2, 0.2, Quantity_TOC_RGB),
+    EmissiveColor(0.0, 0.0, 0.0, Quantity_TOC_RGB),
+    Shininess (1.0f),
+    Transparency (0.0f) {}
+
+};
+
+#endif // _RWGltf_MaterialCommon_HeaderFile

src/RWGltf/RWGltf_MaterialMetallicRoughness.hxx

@@ -0,0 +1,50 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2015-2019 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 _RWGltf_MaterialMetallicRoughness_HeaderFile
+#define _RWGltf_MaterialMetallicRoughness_HeaderFile
+
+#include <Graphic3d_Vec.hxx>
+#include <Quantity_ColorRGBA.hxx>
+#include <Standard_Transient.hxx>
+#include <TCollection_AsciiString.hxx>
+
+class Image_Texture;
+
+//! glTF 2.0 format PBR material definition.
+class RWGltf_MaterialMetallicRoughness : public Standard_Transient
+{
+public:
+
+  Handle(Image_Texture)   BaseColorTexture;         //!< RGB texture for the base color
+  Handle(Image_Texture)   MetallicRoughnessTexture; //!< RG texture packing the metallic and roughness properties together
+  Handle(Image_Texture)   EmissiveTexture;          //!< RGB emissive map controls the color and intensity of the light being emitted by the material
+  Handle(Image_Texture)   OcclusionTexture;         //!< R occlusion map indicating areas of indirect lighting
+  Handle(Image_Texture)   NormalTexture;            //!< normal map
+  TCollection_AsciiString Id;                       //!< material identifier
+  TCollection_AsciiString Name;                     //!< material name
+  Quantity_ColorRGBA      BaseColor;                //!< base color (or scale factor to the texture); [1.0, 1.0, 1.0, 1.0] by default
+  Graphic3d_Vec3          EmissiveFactor;           //!< emissive color; [0.0, 0.0, 0.0] by default
+  Standard_ShortReal      Metallic;                 //!< metalness  (or scale factor to the texture) within range [0.0, 1.0]; 1.0 by default
+  Standard_ShortReal      Roughness;                //!< roughness  (or scale factor to the texture) within range [0.0, 1.0]; 1.0 by default
+
+ RWGltf_MaterialMetallicRoughness()
+  : BaseColor (1.0f, 1.0f, 1.0f, 1.0f),
+    EmissiveFactor (0.0f, 0.0f, 0.0f),
+    Metallic  (0.0f),
+    Roughness (0.0f) {}
+
+};
+
+#endif // _RWGltf_MaterialMetallicRoughness_HeaderFile

src/RWGltf/RWGltf_PrimitiveArrayReader.cxx

@@ -0,0 +1,101 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2019 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 <RWGltf_PrimitiveArrayReader.hxx>
+
+#include <RWGltf_GltfLatePrimitiveArray.hxx>
+
+#include <BRep_Builder.hxx>
+#include <Message.hxx>
+#include <Message_Messenger.hxx>
+#include <OSD_OpenFile.hxx>
+#include <Standard_ArrayStreamBuffer.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Iterator.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(RWGltf_PrimitiveArrayReader, Standard_Transient)
+
+// =======================================================================
+// function : reportError
+// purpose  :
+// =======================================================================
+void RWGltf_PrimitiveArrayReader::reportError (const TCollection_AsciiString& theText)
+{
+  Message::DefaultMessenger()->Send (myErrorPrefix + theText, Message_Fail);
+}
+
+// =======================================================================
+// function : load
+// purpose  :
+// =======================================================================
+bool RWGltf_PrimitiveArrayReader::load (const Handle(RWGltf_GltfLatePrimitiveArray)& theMesh)
+{
+  reset();
+  if (theMesh.IsNull()
+   || theMesh->PrimitiveMode() == RWGltf_GltfPrimitiveMode_UNKNOWN)
+  {
+    return false;
+  }
+
+  for (NCollection_Sequence<RWGltf_GltfPrimArrayData>::Iterator aDataIter (theMesh->Data()); aDataIter.More(); aDataIter.Next())
+  {
+    const RWGltf_GltfPrimArrayData& aData = aDataIter.Value();
+    if (!aData.StreamData.IsNull())
+    {
+      Standard_ArrayStreamBuffer aStreamBuffer ((const char* )aData.StreamData->Data(), aData.StreamData->Size());
+      std::istream aStream (&aStreamBuffer);
+      aStream.seekg ((std::streamoff )aData.StreamOffset, std::ios_base::beg);
+      if (!readBuffer (aStream, theMesh->Id(), aData.Accessor, aData.Type, theMesh->PrimitiveMode()))
+      {
+        return false;
+      }
+      continue;
+    }
+    else if (aData.StreamUri.IsEmpty())
+    {
+      reportError (TCollection_AsciiString ("Buffer '") + theMesh->Id() + "' does not define uri.");
+      return false;
+    }
+
+    if (mySharedStream.Path != aData.StreamUri)
+    {
+      mySharedStream.Stream.close();
+      mySharedStream.Path = aData.StreamUri;
+    }
+    if (!mySharedStream.Stream.is_open())
+    {
+      OSD_OpenStream (mySharedStream.Stream, aData.StreamUri.ToCString(), std::ios::in | std::ios::binary);
+      if (!mySharedStream.Stream.is_open())
+      {
+        mySharedStream.Stream.close();
+        reportError (TCollection_AsciiString ("Buffer '") + theMesh->Id() + "refers to non-existing file '" + aData.StreamUri + "'.");
+        return false;
+      }
+    }
+
+    mySharedStream.Stream.seekg ((std::streamoff )aData.StreamOffset, std::ios_base::beg);
+    if (!mySharedStream.Stream.good())
+    {
+      mySharedStream.Stream.close();
+      reportError (TCollection_AsciiString ("Buffer '") + theMesh->Id() + "refers to invalid location.");
+      return false;
+    }
+
+    if (!readBuffer (mySharedStream.Stream, theMesh->Id(), aData.Accessor, aData.Type, theMesh->PrimitiveMode()))
+    {
+      return false;
+    }
+  }
+  return true;
+}

src/RWGltf/RWGltf_PrimitiveArrayReader.hxx

@@ -0,0 +1,100 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2019 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 _RWGltf_PrimitiveArrayReader_HeaderFile
+#define _RWGltf_PrimitiveArrayReader_HeaderFile
+
+#include <Poly_Triangulation.hxx>
+#include <RWMesh_CoordinateSystemConverter.hxx>
+#include <RWGltf_GltfAccessor.hxx>
+#include <RWGltf_GltfArrayType.hxx>
+#include <RWGltf_GltfPrimitiveMode.hxx>
+#include <TCollection_AsciiString.hxx>
+
+class RWGltf_GltfLatePrimitiveArray;
+
+//! The interface for shared file.
+struct RWGltf_GltfSharedIStream
+{
+  std::ifstream           Stream; //!< shared file
+  TCollection_AsciiString Path;   //!< path to currently opened stream
+};
+
+//! Interface for reading primitive array from glTF buffer.
+class RWGltf_PrimitiveArrayReader : public Standard_Transient
+{
+  DEFINE_STANDARD_RTTIEXT(RWGltf_PrimitiveArrayReader, Standard_Transient)
+public:
+
+  //! Constructor.
+  RWGltf_PrimitiveArrayReader() {}
+
+  //! Return prefix for reporting issues.
+  const TCollection_AsciiString& ErrorPrefix() const { return myErrorPrefix; }
+
+  //! Set prefix for reporting issues.
+  void SetErrorPrefix (const TCollection_AsciiString& theErrPrefix) { myErrorPrefix = theErrPrefix; }
+
+  //! Return transformation from glTF to OCCT coordinate system.
+  const RWMesh_CoordinateSystemConverter& CoordinateSystemConverter() const { return myCoordSysConverter; }
+
+  //! Set transformation from glTF to OCCT coordinate system.
+  void SetCoordinateSystemConverter (const RWMesh_CoordinateSystemConverter& theConverter) { myCoordSysConverter = theConverter; }
+
+  //! Load primitive array.
+  Handle(Poly_Triangulation) Load (const Handle(RWGltf_GltfLatePrimitiveArray)& theMesh)
+  {
+    if (load (theMesh))
+    {
+      return result();
+    }
+    return Handle(Poly_Triangulation)();
+  }
+
+protected:
+
+  //! Reset cache before loading primitive array.
+  Standard_EXPORT virtual void reset() = 0;
+
+  //! Load primitive array.
+  Standard_EXPORT virtual bool load (const Handle(RWGltf_GltfLatePrimitiveArray)& theMesh);
+
+  //! Return result primitive array.
+  Standard_EXPORT virtual Handle(Poly_Triangulation) result() = 0;
+
+  //! Read primitive array data.
+  //! @param theStream   input stream to read from
+  //! @param theName     entity name for logging errors
+  //! @param theAccessor buffer accessor
+  //! @param theType     array type
+  //! @param theMode     primitive mode
+  //! @return FALSE on error
+  Standard_EXPORT virtual bool readBuffer (std::istream& theStream,
+                                           const TCollection_AsciiString& theName,
+                                           const RWGltf_GltfAccessor& theAccessor,
+                                           RWGltf_GltfArrayType theType,
+                                           RWGltf_GltfPrimitiveMode theMode) = 0;
+
+  //! Report error.
+  Standard_EXPORT virtual void reportError (const TCollection_AsciiString& theText);
+
+protected:
+
+  TCollection_AsciiString          myErrorPrefix;
+  RWGltf_GltfSharedIStream         mySharedStream;
+  RWMesh_CoordinateSystemConverter myCoordSysConverter;
+
+};
+
+#endif // _RWGltf_PrimitiveArrayReader_HeaderFile

src/RWGltf/RWGltf_TriangulationReader.cxx

@@ -0,0 +1,434 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2019 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 <RWGltf_TriangulationReader.hxx>
+
+#include <RWMesh_CoordinateSystemConverter.hxx>
+#include <Standard_ReadBuffer.hxx>
+
+#include <BRep_Builder.hxx>
+#include <Graphic3d_Vec.hxx>
+#include <Message.hxx>
+#include <Message_Messenger.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Iterator.hxx>
+
+namespace
+{
+  static const Standard_Integer   THE_LOWER_TRI_INDEX  = 1;
+  static const Standard_Integer   THE_LOWER_NODE_INDEX = 1;
+  static const Standard_ShortReal THE_NORMAL_PREC2 = 0.001f;
+}
+
+IMPLEMENT_STANDARD_RTTIEXT(RWGltf_TriangulationReader, RWGltf_PrimitiveArrayReader)
+
+// =======================================================================
+// function : RWGltf_TriangulationReader
+// purpose  :
+// =======================================================================
+RWGltf_TriangulationReader::RWGltf_TriangulationReader()
+{
+  //
+}
+
+// =======================================================================
+// function : reset
+// purpose  :
+// =======================================================================
+void RWGltf_TriangulationReader::reset()
+{
+  myTriangulation = new Poly_Triangulation (1, 1, true);
+  {
+    TColgp_Array1OfPnt anEmpty;
+    myTriangulation->ChangeNodes().Move (anEmpty);
+  }
+  {
+    TColgp_Array1OfPnt2d anEmpty;
+    myTriangulation->ChangeUVNodes().Move (anEmpty);
+  }
+  {
+    Poly_Array1OfTriangle anEmpty;
+    myTriangulation->ChangeTriangles().Move (anEmpty);
+  }
+}
+
+// =======================================================================
+// function : result
+// purpose  :
+// =======================================================================
+Handle(Poly_Triangulation) RWGltf_TriangulationReader::result()
+{
+  if (myTriangulation->NbNodes() < 1)
+  {
+    return Handle(Poly_Triangulation)();
+  }
+  if (myTriangulation->UVNodes().Size() != myTriangulation->NbNodes())
+  {
+    myTriangulation->RemoveUVNodes();
+  }
+
+  if (myTriangulation->NbTriangles() < 1)
+  {
+    // reconstruct indexes
+    const Standard_Integer aNbTris = myTriangulation->NbNodes() / 3;
+    if (!setNbTriangles (aNbTris))
+    {
+      return Handle(Poly_Triangulation)();
+    }
+
+    for (Standard_Integer aTriIter = 0; aTriIter < aNbTris; ++aTriIter)
+    {
+      setTriangle (THE_LOWER_TRI_INDEX + aTriIter,
+                   Poly_Triangle (THE_LOWER_NODE_INDEX + aTriIter * 3 + 0,
+                                  THE_LOWER_NODE_INDEX + aTriIter * 3 + 1,
+                                  THE_LOWER_NODE_INDEX + aTriIter * 3 + 2));
+    }
+  }
+
+  return myTriangulation;
+}
+
+// =======================================================================
+// function : readBuffer
+// purpose  :
+// =======================================================================
+bool RWGltf_TriangulationReader::readBuffer (std::istream& theStream,
+                                             const TCollection_AsciiString& theName,
+                                             const RWGltf_GltfAccessor& theAccessor,
+                                             RWGltf_GltfArrayType theType,
+                                             RWGltf_GltfPrimitiveMode theMode)
+{
+  if (theMode != RWGltf_GltfPrimitiveMode_Triangles)
+  {
+    Message::DefaultMessenger()->Send (TCollection_AsciiString("Buffer '") + theName + "' skipped unsupported primitive array.", Message_Warning);
+    return true;
+  }
+
+  switch (theType)
+  {
+    case RWGltf_GltfArrayType_Indices:
+    {
+      if (theAccessor.Type != RWGltf_GltfAccessorLayout_Scalar)
+      {
+        break;
+      }
+
+      Poly_Triangle aVec3;
+      if (theAccessor.ComponentType == RWGltf_GltfAccessorCompType_UInt16)
+      {
+        if ((theAccessor.Count / 3) > std::numeric_limits<Standard_Integer>::max())
+        {
+          reportError (TCollection_AsciiString ("Buffer '") + theName + "' defines too big array.");
+          return false;
+        }
+
+        const Standard_Integer aNbTris = (Standard_Integer )(theAccessor.Count / 3);
+        if (!setNbTriangles (aNbTris))
+        {
+          return false;
+        }
+        const size_t aStride = theAccessor.ByteStride != 0
+                             ? theAccessor.ByteStride
+                             : sizeof(uint16_t);
+        Standard_ReadBuffer aBuffer (theAccessor.Count * aStride, aStride);
+        for (Standard_Integer aTriIter = 0; aTriIter < aNbTris; ++aTriIter)
+        {
+          if (const uint16_t* anIndex0 = aBuffer.ReadChunk<uint16_t> (theStream))
+          {
+            aVec3.ChangeValue (1) = THE_LOWER_NODE_INDEX + *anIndex0;
+          }
+          if (const uint16_t* anIndex1 = aBuffer.ReadChunk<uint16_t> (theStream))
+          {
+            aVec3.ChangeValue (2) = THE_LOWER_NODE_INDEX + *anIndex1;
+          }
+          if (const uint16_t* anIndex2 = aBuffer.ReadChunk<uint16_t> (theStream))
+          {
+            aVec3.ChangeValue (3) = THE_LOWER_NODE_INDEX + *anIndex2;
+          }
+          else
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+
+          if (!setTriangle (THE_LOWER_TRI_INDEX + aTriIter, aVec3))
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' refers to invalid indices.");
+          }
+        }
+      }
+      else if (theAccessor.ComponentType == RWGltf_GltfAccessorCompType_UInt32)
+      {
+        if ((theAccessor.Count / 3) > std::numeric_limits<Standard_Integer>::max())
+        {
+          reportError (TCollection_AsciiString ("Buffer '") + theName + "' defines too big array.");
+          return false;
+        }
+
+        const int aNbTris = (Standard_Integer )(theAccessor.Count / 3);
+        if (!setNbTriangles (aNbTris))
+        {
+          return false;
+        }
+        const size_t aStride = theAccessor.ByteStride != 0
+                             ? theAccessor.ByteStride
+                             : sizeof(uint32_t);
+        Standard_ReadBuffer aBuffer (theAccessor.Count * aStride, aStride);
+        for (Standard_Integer aTriIter = 0; aTriIter < aNbTris; ++aTriIter)
+        {
+          if (const uint32_t* anIndex0 = aBuffer.ReadChunk<uint32_t> (theStream))
+          {
+            aVec3.ChangeValue (1) = THE_LOWER_NODE_INDEX + *anIndex0;
+          }
+          if (const uint32_t* anIndex1 = aBuffer.ReadChunk<uint32_t> (theStream))
+          {
+            aVec3.ChangeValue (2) = THE_LOWER_NODE_INDEX + *anIndex1;
+          }
+          if (const uint32_t* anIndex2 = aBuffer.ReadChunk<uint32_t> (theStream))
+          {
+            aVec3.ChangeValue (3) = THE_LOWER_NODE_INDEX + *anIndex2;
+          }
+          else
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+
+          if (!setTriangle (THE_LOWER_TRI_INDEX + aTriIter, aVec3))
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' refers to invalid indices.");
+          }
+        }
+      }
+      else if (theAccessor.ComponentType == RWGltf_GltfAccessorCompType_UInt8)
+      {
+        if ((theAccessor.Count / 3) > std::numeric_limits<Standard_Integer>::max())
+        {
+          reportError (TCollection_AsciiString ("Buffer '") + theName + "' defines too big array.");
+          return false;
+        }
+
+        const Standard_Integer aNbTris = (Standard_Integer )(theAccessor.Count / 3);
+        if (!setNbTriangles (aNbTris))
+        {
+          return false;
+        }
+        const size_t aStride = theAccessor.ByteStride != 0
+                             ? theAccessor.ByteStride
+                             : sizeof(uint8_t);
+        Standard_ReadBuffer aBuffer (theAccessor.Count * aStride, aStride);
+        for (Standard_Integer aTriIter = 0; aTriIter < aNbTris; ++aTriIter)
+        {
+          if (const uint8_t* anIndex0 = aBuffer.ReadChunk<uint8_t> (theStream))
+          {
+            aVec3.ChangeValue (1) = THE_LOWER_NODE_INDEX + (Standard_Integer )*anIndex0;
+          }
+          if (const uint8_t* anIndex1 = aBuffer.ReadChunk<uint8_t> (theStream))
+          {
+            aVec3.ChangeValue (2) = THE_LOWER_NODE_INDEX + (Standard_Integer )*anIndex1;
+          }
+          if (const uint8_t* anIndex2 = aBuffer.ReadChunk<uint8_t> (theStream))
+          {
+            aVec3.ChangeValue (3) = THE_LOWER_NODE_INDEX + (Standard_Integer )*anIndex2;
+          }
+          else
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+
+          if (!setTriangle (THE_LOWER_TRI_INDEX + aTriIter, aVec3))
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' refers to invalid indices.");
+          }
+        }
+      }
+      else
+      {
+        break;
+      }
+
+      break;
+    }
+    case RWGltf_GltfArrayType_Position:
+    {
+      if (theAccessor.ComponentType != RWGltf_GltfAccessorCompType_Float32
+       || theAccessor.Type != RWGltf_GltfAccessorLayout_Vec3)
+      {
+        break;
+      }
+      else if (theAccessor.Count > std::numeric_limits<Standard_Integer>::max())
+      {
+        reportError (TCollection_AsciiString ("Buffer '") + theName + "' defines too big array.");
+        return false;
+      }
+
+      const size_t aStride = theAccessor.ByteStride != 0
+                           ? theAccessor.ByteStride
+                           : sizeof(Graphic3d_Vec3);
+      const Standard_Integer aNbNodes = (Standard_Integer )theAccessor.Count;
+      if (!setNbPositionNodes (aNbNodes))
+      {
+        return false;
+      }
+
+      Standard_ReadBuffer aBuffer (theAccessor.Count * aStride, aStride);
+      if (!myCoordSysConverter.IsEmpty())
+      {
+        for (Standard_Integer aVertIter = 0; aVertIter < aNbNodes; ++aVertIter)
+        {
+          const Graphic3d_Vec3* aVec3 = aBuffer.ReadChunk<Graphic3d_Vec3> (theStream);
+          if (aVec3 == NULL)
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+
+          gp_Pnt anXYZ (aVec3->x(), aVec3->y(), aVec3->z());
+          myCoordSysConverter.TransformPosition (anXYZ.ChangeCoord());
+          setNodePosition (THE_LOWER_NODE_INDEX + aVertIter, anXYZ);
+        }
+      }
+      else
+      {
+        for (Standard_Integer aVertIter = 0; aVertIter < aNbNodes; ++aVertIter)
+        {
+          const Graphic3d_Vec3* aVec3 = aBuffer.ReadChunk<Graphic3d_Vec3> (theStream);
+          if (aVec3 == NULL)
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+          setNodePosition (THE_LOWER_NODE_INDEX + aVertIter, gp_Pnt (aVec3->x(), aVec3->y(), aVec3->z()));
+        }
+      }
+      break;
+    }
+    case RWGltf_GltfArrayType_Normal:
+    {
+      if (theAccessor.ComponentType != RWGltf_GltfAccessorCompType_Float32
+       || theAccessor.Type != RWGltf_GltfAccessorLayout_Vec3)
+      {
+        break;
+      }
+      else if (theAccessor.Count > std::numeric_limits<Standard_Integer>::max())
+      {
+        reportError (TCollection_AsciiString ("Buffer '") + theName + "' defines too big array.");
+        return false;
+      }
+
+      const size_t aStride = theAccessor.ByteStride != 0
+                           ? theAccessor.ByteStride
+                           : sizeof(Graphic3d_Vec3);
+      const Standard_Integer aNbNodes = (Standard_Integer )theAccessor.Count;
+      if (!setNbNormalNodes (aNbNodes))
+      {
+        return false;
+      }
+      Standard_ReadBuffer aBuffer (theAccessor.Count * aStride, aStride);
+      if (!myCoordSysConverter.IsEmpty())
+      {
+        for (Standard_Integer aVertIter = 0; aVertIter < aNbNodes; ++aVertIter)
+        {
+          Graphic3d_Vec3* aVec3 = aBuffer.ReadChunk<Graphic3d_Vec3> (theStream);
+          if (aVec3 == NULL)
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+          if (aVec3->SquareModulus() >= THE_NORMAL_PREC2)
+          {
+            myCoordSysConverter.TransformNormal (*aVec3);
+            setNodeNormal (THE_LOWER_NODE_INDEX + aVertIter, gp_Dir (aVec3->x(), aVec3->y(), aVec3->z()));
+          }
+          else
+          {
+            setNodeNormal (THE_LOWER_NODE_INDEX + aVertIter, gp_Dir (0.0, 0.0, 1.0));
+          }
+        }
+      }
+      else
+      {
+        for (Standard_Integer aVertIter = 0; aVertIter < aNbNodes; ++aVertIter)
+        {
+          const Graphic3d_Vec3* aVec3 = aBuffer.ReadChunk<Graphic3d_Vec3> (theStream);
+          if (aVec3 == NULL)
+          {
+            reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+            return false;
+          }
+          if (aVec3->SquareModulus() >= THE_NORMAL_PREC2)
+          {
+            setNodeNormal (THE_LOWER_NODE_INDEX + aVertIter, gp_Dir (aVec3->x(), aVec3->y(), aVec3->z()));
+          }
+          else
+          {
+            setNodeNormal (THE_LOWER_NODE_INDEX + aVertIter, gp_Dir (0.0, 0.0, 1.0));
+          }
+        }
+      }
+      break;
+    }
+    case RWGltf_GltfArrayType_TCoord0:
+    {
+      if (theAccessor.ComponentType != RWGltf_GltfAccessorCompType_Float32
+       || theAccessor.Type != RWGltf_GltfAccessorLayout_Vec2)
+      {
+        break;
+      }
+      else if (theAccessor.Count > std::numeric_limits<Standard_Integer>::max())
+      {
+        reportError (TCollection_AsciiString ("Buffer '") + theName + "' defines too big array.");
+        return false;
+      }
+
+      const size_t aStride = theAccessor.ByteStride != 0
+                           ? theAccessor.ByteStride
+                           : sizeof(Graphic3d_Vec2);
+      const Standard_Integer aNbNodes = (Standard_Integer )theAccessor.Count;
+      if (!setNbUVNodes (aNbNodes))
+      {
+        return false;
+      }
+
+      Standard_ReadBuffer aBuffer (theAccessor.Count * aStride, aStride);
+      for (int aVertIter = 0; aVertIter < aNbNodes; ++aVertIter)
+      {
+        Graphic3d_Vec2* aVec2 = aBuffer.ReadChunk<Graphic3d_Vec2> (theStream);
+        if (aVec2 == NULL)
+        {
+          reportError (TCollection_AsciiString ("Buffer '") + theName + "' reading error.");
+          return false;
+        }
+
+        // Y should be flipped (relative to image layout used by OCCT)
+        aVec2->y() = 1.0f - aVec2->y();
+        setNodeUV (THE_LOWER_NODE_INDEX + aVertIter, gp_Pnt2d (aVec2->x(), aVec2->y()));
+      }
+      break;
+    }
+    case RWGltf_GltfArrayType_Color:
+    case RWGltf_GltfArrayType_TCoord1:
+    case RWGltf_GltfArrayType_Joint:
+    case RWGltf_GltfArrayType_Weight:
+    {
+      return true;
+    }
+    case RWGltf_GltfArrayType_UNKNOWN:
+    {
+      return false;
+    }
+  }
+  return true;
+}

src/RWGltf/RWGltf_TriangulationReader.hxx

@@ -0,0 +1,148 @@
+// Author: Kirill Gavrilov
+// Copyright (c) 2019 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 _RWGltf_TriangulationReader_HeaderFile
+#define _RWGltf_TriangulationReader_HeaderFile
+
+#include <RWGltf_PrimitiveArrayReader.hxx>
+
+//! RWGltf_PrimitiveArrayReader implementation creating Poly_Triangulation.
+class RWGltf_TriangulationReader : public RWGltf_PrimitiveArrayReader
+{
+  DEFINE_STANDARD_RTTIEXT(RWGltf_TriangulationReader, RWGltf_PrimitiveArrayReader)
+public:
+
+  //! Empty constructor.
+  Standard_EXPORT RWGltf_TriangulationReader();
+
+protected:
+
+  //! Create Poly_Triangulation from collected data
+  Standard_EXPORT virtual Handle(Poly_Triangulation) result() Standard_OVERRIDE;
+
+  //! Reset cache before loading primitive array.
+  Standard_EXPORT virtual void reset() Standard_OVERRIDE;
+
+  //! Fill triangulation data and ignore non-triangulation primitives.
+  //! @param theStream   input stream to read from
+  //! @param theName     entity name for logging errors
+  //! @param theAccessor buffer accessor
+  //! @param theType     array type
+  //! @param theMode     primitive mode
+  //! @return FALSE on error
+  Standard_EXPORT virtual bool readBuffer (std::istream& theStream,
+                                           const TCollection_AsciiString& theName,
+                                           const RWGltf_GltfAccessor& theAccessor,
+                                           RWGltf_GltfArrayType theType,
+                                           RWGltf_GltfPrimitiveMode theMode) Standard_OVERRIDE;
+
+protected: //! @name interface for filling triangulation data
+
+  //! Resize array of position nodes to specified size.
+  virtual bool setNbPositionNodes (Standard_Integer theNbNodes)
+  {
+    if (theNbNodes <= 0)
+    {
+      return false;
+    }
+    myTriangulation->ChangeNodes().Resize (1, theNbNodes, false);
+    return true;
+  }
+
+  //! Set node position.
+  //! @param theIndex node index starting from 1
+  //! @param thePnt   node position
+  virtual void setNodePosition (Standard_Integer theIndex,
+                                const gp_Pnt& thePnt)
+  {
+    myTriangulation->ChangeNode (theIndex) = thePnt;
+  }
+
+  //! Resize array of UV nodes to specified size.
+  virtual bool setNbUVNodes (Standard_Integer theNbNodes)
+  {
+    if (theNbNodes <= 0
+     || myTriangulation->NbNodes() != theNbNodes)
+    {
+      return false;
+    }
+    myTriangulation->ChangeUVNodes().Resize (1, theNbNodes, false);
+    return true;
+  }
+
+  //! Set node UV texture coordinates.
+  //! @param theIndex node index starting from 1
+  //! @param theUV    node UV coordinates
+  virtual void setNodeUV (Standard_Integer theIndex,
+                          const gp_Pnt2d& theUV)
+  {
+    myTriangulation->ChangeUVNode (theIndex) = theUV;
+  }
+
+  //! Resize array of nodes normals to specified size.
+  virtual bool setNbNormalNodes (Standard_Integer theNbNodes)
+  {
+    if (theNbNodes <= 0
+     || myTriangulation->NbNodes() != theNbNodes)
+    {
+      return false;
+    }
+    myTriangulation->SetNormals (new TShort_HArray1OfShortReal (1, theNbNodes * 3));
+    return true;
+  }
+
+  //! Set node normal.
+  //! @param theIndex  node index starting from 1
+  //! @param theNormal node normal
+  virtual void setNodeNormal (Standard_Integer theIndex,
+                              const gp_Dir& theNormal)
+  {
+    myTriangulation->SetNormal (theIndex, theNormal);
+  }
+
+  //! Resize array of triangles to specified size.
+  virtual bool setNbTriangles (Standard_Integer theNbTris)
+  {
+    if (theNbTris >= 1)
+    {
+      myTriangulation->ChangeTriangles().Resize (1, theNbTris, false);
+      return true;
+    }
+    return false;
+  }
+
+  //! Add triangle element.
+  //! @param theIndex    triangle index starting from 1
+  //! @param theTriangle triangle nodes starting from 1
+  //! @return FALSE if node indexes are out of range
+  virtual bool setTriangle (Standard_Integer theIndex,
+                            const Poly_Triangle& theTriangle)
+  {
+    if (theTriangle.Value (1) < myTriangulation->Nodes().Lower() || theTriangle.Value (1) > myTriangulation->Nodes().Upper()
+     || theTriangle.Value (2) < myTriangulation->Nodes().Lower() || theTriangle.Value (2) > myTriangulation->Nodes().Upper()
+     || theTriangle.Value (3) < myTriangulation->Nodes().Lower() || theTriangle.Value (3) > myTriangulation->Nodes().Upper())
+    {
+      return false;
+    }
+    myTriangulation->ChangeTriangle (theIndex) = theTriangle;
+    return true;
+  }
+
+protected:
+
+  Handle(Poly_Triangulation) myTriangulation;
+
+};
+
+#endif // _RWGltf_TriangulationReader_HeaderFile

src/Standard/Standard_TypeDef.hxx

@@ -26,10 +26,10 @@
   typedef unsigned __int32  uint32_t;
   typedef unsigned __int64  uint64_t;
 
-  typedef __int8   int8_t;
+  typedef signed __int8   int8_t;
-  typedef __int16  int16_t;
+  typedef signed __int16  int16_t;
-  typedef __int32  int32_t;
+  typedef signed __int32  int32_t;
-  typedef __int64  int64_t;
+  typedef signed __int64  int64_t;
 #else
   #include <stdint.h>
 #endif

src/TKRWMesh/EXTERNLIB

@@ -7,3 +7,4 @@ TKV3d
 TKBRep
 TKG3d
 TKService
+CSF_RapidJSON

src/TKRWMesh/PACKAGES

@@ -1 +1,2 @@
+RWGltf
 RWMesh

src/XSDRAWSTLVRML/XSDRAWSTLVRML.cxx

@@ -19,6 +19,8 @@
 #include <Bnd_Box.hxx>
 #include <BRep_Builder.hxx>
 #include <DBRep.hxx>
+#include <DDocStd.hxx>
+#include <DDocStd_DrawDocument.hxx>
 #include <Draw.hxx>
 #include <Draw_Interpretor.hxx>
 #include <Draw_PluginMacro.hxx>
@@ -40,6 +42,7 @@
 #include <Quantity_Color.hxx>
 #include <Quantity_HArray1OfColor.hxx>
 #include <Quantity_NameOfColor.hxx>
+#include <RWGltf_CafReader.hxx>
 #include <RWStl.hxx>
 #include <SelectMgr_SelectionManager.hxx>
 #include <Standard_ErrorHandler.hxx>
@@ -51,8 +54,11 @@
 #include <TColStd_Array1OfReal.hxx>
 #include <TColStd_HPackedMapOfInteger.hxx>
 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
+#include <TDataStd_Name.hxx>
+#include <TDocStd_Application.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopoDS_Shape.hxx>
+#include <UnitsAPI.hxx>
 #include <UnitsMethods.hxx>
 #include <V3d_View.hxx>
 #include <ViewerTest.hxx>
@@ -77,6 +83,126 @@ extern Standard_Boolean VDisplayAISObject (const TCollection_AsciiString& theNam
                                            const Handle(AIS_InteractiveObject)& theAISObj,
                                            Standard_Boolean theReplaceIfExists = Standard_True);
 
+//=============================================================================
+//function : ReadGltf
+//purpose  : Reads glTF file
+//=============================================================================
+static Standard_Integer ReadGltf (Draw_Interpretor& theDI,
+                                  Standard_Integer theNbArgs,
+                                  const char** theArgVec)
+{
+  TCollection_AsciiString aDestName, aFilePath;
+  Standard_Boolean toUseExistingDoc = Standard_False;
+  Standard_Real aSystemUnitFactor = UnitsMethods::GetCasCadeLengthUnit() * 0.001;
+  Standard_Boolean toListExternalFiles = Standard_False;
+  Standard_Boolean isParallel = Standard_False;
+  Standard_Boolean isNoDoc = (TCollection_AsciiString(theArgVec[0]) == "readgltf");
+  for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
+  {
+    TCollection_AsciiString anArgCase (theArgVec[anArgIter]);
+    anArgCase.LowerCase();
+    if (!isNoDoc
+     && (anArgCase == "-nocreate"
+      || anArgCase == "-nocreatedoc"))
+    {
+      toUseExistingDoc = Standard_True;
+      if (anArgIter + 1 < theNbArgs
+       && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toUseExistingDoc))
+      {
+        ++anArgIter;
+      }
+    }
+    else if (anArgCase == "-parallel")
+    {
+      isParallel = Standard_True;
+      if (anArgIter + 1 < theNbArgs
+       && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], isParallel))
+      {
+        ++anArgIter;
+      }
+    }
+    else if (anArgCase == "-listexternalfiles"
+          || anArgCase == "-listexternals"
+          || anArgCase == "-listexternal"
+          || anArgCase == "-external"
+          || anArgCase == "-externalfiles")
+    {
+      toListExternalFiles = Standard_True;
+    }
+    else if (aDestName.IsEmpty())
+    {
+      aDestName = theArgVec[anArgIter];
+    }
+    else if (aFilePath.IsEmpty())
+    {
+      aFilePath = theArgVec[anArgIter];
+    }
+    else
+    {
+      std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+      return 1;
+    }
+  }
+  if (aFilePath.IsEmpty())
+  {
+    std::cout << "Syntax error: wrong number of arguments\n";
+    return 1;
+  }
+
+  Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (theDI, 1);
+  Handle(TDocStd_Document) aDoc;
+  if (!toListExternalFiles
+   && !isNoDoc)
+  {
+    Handle(TDocStd_Application) anApp = DDocStd::GetApplication();
+    Standard_CString aNameVar = aDestName.ToCString();
+    DDocStd::GetDocument (aNameVar, aDoc, Standard_False);
+    if (aDoc.IsNull())
+    {
+      if (toUseExistingDoc)
+      {
+        std::cout << "Error: document with name " << aDestName << " does not exist\n";
+        return 1;
+      }
+      anApp->NewDocument (TCollection_ExtendedString ("BinXCAF"), aDoc);
+    }
+    else if (!toUseExistingDoc)
+    {
+      std::cout << "Error: document with name " << aDestName << " already exists\n";
+      return 1;
+    }
+  }
+
+  RWGltf_CafReader aReader;
+  aReader.SetSystemLengthUnit (aSystemUnitFactor);
+  aReader.SetSystemCoordinateSystem (RWMesh_CoordinateSystem_Zup);
+  aReader.SetDocument (aDoc);
+  aReader.SetParallel (isParallel);
+  if (toListExternalFiles)
+  {
+    aReader.ProbeHeader (aFilePath);
+    for (NCollection_IndexedMap<TCollection_AsciiString>::Iterator aFileIter (aReader.ExternalFiles()); aFileIter.More(); aFileIter.Next())
+    {
+      theDI << "\"" << aFileIter.Value() << "\" ";
+    }
+  }
+  else
+  {
+    aReader.Perform (aFilePath, aProgress);
+    if (isNoDoc)
+    {
+      DBRep::Set (aDestName.ToCString(), aReader.SingleShape());
+    }
+    else
+    {
+      Handle(DDocStd_DrawDocument) aDrawDoc = new DDocStd_DrawDocument (aDoc);
+      TDataStd_Name::Set (aDoc->GetData()->Root(), aDestName.ToCString());
+      Draw::Set (aDestName.ToCString(), aDrawDoc);
+    }
+  }
+  return 0;
+}
+
 static Standard_Integer writestl
 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 {
@@ -1259,6 +1385,16 @@ void  XSDRAWSTLVRML::InitCommands (Draw_Interpretor& theCommands)
   const char* g = "XSTEP-STL/VRML";  // Step transfer file commands
   //XSDRAW::LoadDraw(theCommands);
 
+  theCommands.Add ("ReadGltf",
+                   "ReadGltf Doc file [-parallel {on|off}] [-listExternalFiles] [-noCreateDoc]"
+                   "\n\t\t: Read glTF file into XDE document."
+                   "\n\t\t:   -listExternalFiles do not read mesh and only list external files"
+                   "\n\t\t:   -noCreateDoc read into existing XDE document",
+                   __FILE__, ReadGltf, g);
+  theCommands.Add ("readgltf",
+                   "readgltf shape file"
+                   "\n\t\t: Same as ReadGltf but reads glTF file into a shape instead of a document.",
+                   __FILE__, ReadGltf, g);
   theCommands.Add ("writevrml", "shape file [version VRML#1.0/VRML#2.0 (1/2): 2 by default] [representation shaded/wireframe/both (0/1/2): 1 by default]",__FILE__,writevrml,g);
   theCommands.Add ("writestl",  "shape file [ascii/binary (0/1) : 1 by default] [InParallel (0/1) : 0 by default]",__FILE__,writestl,g);
   theCommands.Add ("readstl",

tests/de_mesh/gltf_read/begin

@@ -0,0 +1,2 @@
+pload XDE OCAF MODELING VISUALIZATION
+catch { Close D }

tests/de_mesh/gltf_read/brainstem

@@ -0,0 +1,8 @@
+puts "========"
+puts "0030691: test glTF reader on standard sample models"
+puts "========"
+
+ReadGltf D [locate_data_file bug30691_BrainStem.gltf]
+XGetOneShape s D
+checknbshapes s -face 59 -compound 1
+checktrinfo s -tri 61666 -nod 34159

tests/de_mesh/gltf_read/buggy

@@ -0,0 +1,8 @@
+puts "========"
+puts "0030691: test glTF reader on standard sample models"
+puts "========"
+
+ReadGltf D [locate_data_file bug30691_Buggy.glb]
+XGetOneShape s D
+checknbshapes s -face 148 -compound 48
+checktrinfo s -tri 531955 -nod 412855

tests/de_mesh/gltf_read/end

@@ -0,0 +1,6 @@
+vclear
+vinit View1
+XDisplay -dispMode 1 D
+vaxo
+vfit
+vdump ${imagedir}/${casename}.png

tests/de_mesh/gltf_read/engine

@@ -0,0 +1,8 @@
+puts "========"
+puts "0030691: test glTF reader on standard sample models"
+puts "========"
+
+ReadGltf D [locate_data_file bug30691_2CylinderEngine.glb]
+XGetOneShape s D
+checknbshapes s -face 34 -compound 18
+checktrinfo s -tri 121496 -nod 84657

tests/de_mesh/gltf_read/helmet

@@ -0,0 +1,8 @@
+puts "========"
+puts "0030691: test glTF reader on standard sample models"
+puts "========"
+
+ReadGltf D [locate_data_file bug30691_DamagedHelmet.gltf]
+XGetOneShape s D
+checknbshapes s -face 1 -compound 0
+checktrinfo s -tri 15452 -nod 14556

tests/de_mesh/gltf_read/lantern

@@ -0,0 +1,8 @@
+puts "========"
+puts "0030691: test glTF reader on standard sample models"
+puts "========"
+
+ReadGltf D [locate_data_file bug30691_Lantern.glb]
+XGetOneShape s D
+checknbshapes s -face 3 -compound 1
+checktrinfo s -tri 5394 -nod 4145

tests/de_mesh/gltf_read/orient

@@ -0,0 +1,8 @@
+puts "========"
+puts "0030691: test glTF reader on standard sample models"
+puts "========"
+
+ReadGltf D [locate_data_file bug30691_OrientationTest.glb]
+XGetOneShape s D
+checknbshapes s -face 13 -compound 1
+checktrinfo s -tri 524 -nod 1048

tests/de_mesh/grids.list

@@ -1,2 +1,3 @@
 001 stl_read
 002 shape_write_stl
+003 gltf_read

tests/de_mesh/parse.rules

@@ -0,0 +1 @@
+SKIPPED /Error: glTF reader is unavailable - OCCT has been built without RapidJSON support/