mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-03 17:56:21 +03:00
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.
This commit is contained in:
kgv
bugmaster
parent
eec6e810f1
commit
0a419c51ed
@ -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}")
|
||||
|
||||
@ -440,4 +440,5 @@ t TKVCAF
|
||||
n XCAFView
|
||||
n XCAFNoteObjects
|
||||
t TKRWMesh
|
||||
n RWGltf
|
||||
n RWMesh
|
||||
|
||||
86
adm/cmake/rapidjson.cmake
Normal file
86
adm/cmake/rapidjson.cmake
Normal file
@ -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)
|
||||
@ -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")
|
||||
|
||||
@ -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.myQt4Lbl -row $aCheckRowIter -column 11 -sticky w
|
||||
grid .myFrame.myChecks.myQt4Check -row $aCheckRowIter -column 12 -sticky e
|
||||
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.myJDKLbl -row $aCheckRowIter -column 11 -sticky w
|
||||
grid .myFrame.myChecks.myJDKCheck -row $aCheckRowIter -column 12 -sticky e
|
||||
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
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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=;"
|
||||
|
||||
@ -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 |
|
||||
|
||||
@ -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
|
||||
|
||||
22
src/RWGltf/FILES
Normal file
22
src/RWGltf/FILES
Normal file
@ -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
|
||||
295
src/RWGltf/RWGltf_CafReader.cxx
Normal file
295
src/RWGltf/RWGltf_CafReader.cxx
Normal file
@ -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;
|
||||
}
|
||||
65
src/RWGltf/RWGltf_CafReader.hxx
Normal file
65
src/RWGltf/RWGltf_CafReader.hxx
Normal file
@ -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
|
||||
48
src/RWGltf/RWGltf_GltfAccessor.hxx
Normal file
48
src/RWGltf/RWGltf_GltfAccessor.hxx
Normal file
@ -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
|
||||
30
src/RWGltf/RWGltf_GltfAccessorCompType.hxx
Normal file
30
src/RWGltf/RWGltf_GltfAccessorCompType.hxx
Normal file
@ -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
|
||||
68
src/RWGltf/RWGltf_GltfAccessorLayout.hxx
Normal file
68
src/RWGltf/RWGltf_GltfAccessorLayout.hxx
Normal file
@ -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
|
||||
68
src/RWGltf/RWGltf_GltfArrayType.hxx
Normal file
68
src/RWGltf/RWGltf_GltfArrayType.hxx
Normal file
@ -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
|
||||
38
src/RWGltf/RWGltf_GltfBufferView.hxx
Normal file
38
src/RWGltf/RWGltf_GltfBufferView.hxx
Normal file
@ -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
|
||||
26
src/RWGltf/RWGltf_GltfBufferViewTarget.hxx
Normal file
26
src/RWGltf/RWGltf_GltfBufferViewTarget.hxx
Normal file
@ -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
|
||||
29
src/RWGltf/RWGltf_GltfFace.hxx
Normal file
29
src/RWGltf/RWGltf_GltfFace.hxx
Normal file
@ -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
|
||||
1623
src/RWGltf/RWGltf_GltfJsonParser.cxx
Normal file
1623
src/RWGltf/RWGltf_GltfJsonParser.cxx
Normal file
File diff suppressed because it is too large
Load Diff
416
src/RWGltf/RWGltf_GltfJsonParser.pxx
Normal file
416
src/RWGltf/RWGltf_GltfJsonParser.pxx
Normal file
@ -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
|
||||
133
src/RWGltf/RWGltf_GltfLatePrimitiveArray.cxx
Normal file
133
src/RWGltf/RWGltf_GltfLatePrimitiveArray.cxx
Normal file
@ -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();
|
||||
}
|
||||
99
src/RWGltf/RWGltf_GltfLatePrimitiveArray.hxx
Normal file
99
src/RWGltf/RWGltf_GltfLatePrimitiveArray.hxx
Normal file
@ -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
|
||||
41
src/RWGltf/RWGltf_GltfPrimArrayData.hxx
Normal file
41
src/RWGltf/RWGltf_GltfPrimArrayData.hxx
Normal file
@ -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
|
||||
32
src/RWGltf/RWGltf_GltfPrimitiveMode.hxx
Normal file
32
src/RWGltf/RWGltf_GltfPrimitiveMode.hxx
Normal file
@ -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
|
||||
73
src/RWGltf/RWGltf_GltfRootElement.hxx
Normal file
73
src/RWGltf/RWGltf_GltfRootElement.hxx
Normal file
@ -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
|
||||
48
src/RWGltf/RWGltf_MaterialCommon.hxx
Normal file
48
src/RWGltf/RWGltf_MaterialCommon.hxx
Normal file
@ -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
|
||||
50
src/RWGltf/RWGltf_MaterialMetallicRoughness.hxx
Normal file
50
src/RWGltf/RWGltf_MaterialMetallicRoughness.hxx
Normal file
@ -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
|
||||
101
src/RWGltf/RWGltf_PrimitiveArrayReader.cxx
Normal file
101
src/RWGltf/RWGltf_PrimitiveArrayReader.cxx
Normal file
@ -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;
|
||||
}
|
||||
100
src/RWGltf/RWGltf_PrimitiveArrayReader.hxx
Normal file
100
src/RWGltf/RWGltf_PrimitiveArrayReader.hxx
Normal file
@ -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
|
||||
434
src/RWGltf/RWGltf_TriangulationReader.cxx
Normal file
434
src/RWGltf/RWGltf_TriangulationReader.cxx
Normal file
@ -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;
|
||||
}
|
||||
148
src/RWGltf/RWGltf_TriangulationReader.hxx
Normal file
148
src/RWGltf/RWGltf_TriangulationReader.hxx
Normal file
@ -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
|
||||
@ -26,10 +26,10 @@
|
||||
typedef unsigned __int32 uint32_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
|
||||
typedef __int8 int8_t;
|
||||
typedef __int16 int16_t;
|
||||
typedef __int32 int32_t;
|
||||
typedef __int64 int64_t;
|
||||
typedef signed __int8 int8_t;
|
||||
typedef signed __int16 int16_t;
|
||||
typedef signed __int32 int32_t;
|
||||
typedef signed __int64 int64_t;
|
||||
#else
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
@ -7,3 +7,4 @@ TKV3d
|
||||
TKBRep
|
||||
TKG3d
|
||||
TKService
|
||||
CSF_RapidJSON
|
||||
|
||||
@ -1 +1,2 @@
|
||||
RWGltf
|
||||
RWMesh
|
||||
|
||||
@ -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",
|
||||
|
||||
2
tests/de_mesh/gltf_read/begin
Normal file
2
tests/de_mesh/gltf_read/begin
Normal file
@ -0,0 +1,2 @@
|
||||
pload XDE OCAF MODELING VISUALIZATION
|
||||
catch { Close D }
|
||||
8
tests/de_mesh/gltf_read/brainstem
Normal file
8
tests/de_mesh/gltf_read/brainstem
Normal file
@ -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
|
||||
8
tests/de_mesh/gltf_read/buggy
Normal file
8
tests/de_mesh/gltf_read/buggy
Normal file
@ -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
|
||||
6
tests/de_mesh/gltf_read/end
Normal file
6
tests/de_mesh/gltf_read/end
Normal file
@ -0,0 +1,6 @@
|
||||
vclear
|
||||
vinit View1
|
||||
XDisplay -dispMode 1 D
|
||||
vaxo
|
||||
vfit
|
||||
vdump ${imagedir}/${casename}.png
|
||||
8
tests/de_mesh/gltf_read/engine
Normal file
8
tests/de_mesh/gltf_read/engine
Normal file
@ -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
|
||||
8
tests/de_mesh/gltf_read/helmet
Normal file
8
tests/de_mesh/gltf_read/helmet
Normal file
@ -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
|
||||
8
tests/de_mesh/gltf_read/lantern
Normal file
8
tests/de_mesh/gltf_read/lantern
Normal file
@ -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
|
||||
8
tests/de_mesh/gltf_read/orient
Normal file
8
tests/de_mesh/gltf_read/orient
Normal file
@ -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
|
||||
@ -1,2 +1,3 @@
|
||||
001 stl_read
|
||||
002 shape_write_stl
|
||||
003 gltf_read
|
||||
|
||||
1
tests/de_mesh/parse.rules
Normal file
1
tests/de_mesh/parse.rules
Normal file
@ -0,0 +1 @@
|
||||
SKIPPED /Error: glTF reader is unavailable - OCCT has been built without RapidJSON support/
|
||||
Loading…
x
Reference in New Issue
Block a user