diff --git a/.gitignore b/.gitignore index 49cd60ca8..9dcb6623d 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,12 @@ build *.sln *.ncb *.vcproj +*.vcxproj.user +*.VC.db +*.VC.db-shm +*.VC.db-wal +*.VC.opendb +*.ipch # Output bin/ @@ -32,6 +38,7 @@ cmake_uninstall.cmake *.dir/ assimp-config.cmake assimp-config-version.cmake +assimpTargets*.cmake # MakeFile Makefile diff --git a/CMakeLists.txt b/CMakeLists.txt index cda2d4e84..ad0462531 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ # Open Asset Import Library (assimp) # ---------------------------------------------------------------------- # Copyright (c) 2006-2019, assimp team - +# # All rights reserved. # # Redistribution and use of this software in source and binary forms, @@ -34,9 +34,24 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #---------------------------------------------------------------------- -SET(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required -CMAKE_MINIMUM_REQUIRED( VERSION 2.8 ) -PROJECT( Assimp ) +SET(CMAKE_POLICY_DEFAULT_CMP0074 NEW) + +CMAKE_MINIMUM_REQUIRED( VERSION 3.0 ) + +# Toggles the use of the hunter package manager +option(HUNTER_ENABLED "Enable Hunter package manager support" OFF) + +include("cmake/HunterGate.cmake") +HunterGate( + URL "https://github.com/ruslo/hunter/archive/v0.23.176.tar.gz" + SHA1 "2e9ae973d028660b735ac4c6142725ca36a0048a" +) + +IF(HUNTER_ENABLED) + add_definitions(-DASSIMP_USE_HUNTER) +ENDIF(HUNTER_ENABLED) + +PROJECT( Assimp VERSION 5.0.0 ) # All supported options ############################################### @@ -67,7 +82,7 @@ OPTION( ASSIMP_NO_EXPORT ) OPTION( ASSIMP_BUILD_ZLIB "Build your own zlib" - OFF + OFF ) OPTION( ASSIMP_BUILD_ASSIMP_TOOLS "If the supplementary tools for Assimp are built in addition to the library." @@ -115,12 +130,12 @@ OPTION ( IGNORE_GIT_HASH OFF ) -IF (IOS) +IF (IOS AND NOT HUNTER_ENABLED) IF (NOT CMAKE_BUILD_TYPE) SET(CMAKE_BUILD_TYPE "Release") ENDIF (NOT CMAKE_BUILD_TYPE) ADD_DEFINITIONS(-DENABLE_BITCODE) -ENDIF (IOS) +ENDIF (IOS AND NOT HUNTER_ENABLED) # Use subset of Windows.h if (WIN32) @@ -151,17 +166,18 @@ ELSE() ENDIF(NOT BUILD_SHARED_LIBS) # Define here the needed parameters -SET (ASSIMP_VERSION_MAJOR 5) -SET (ASSIMP_VERSION_MINOR 0) -SET (ASSIMP_VERSION_PATCH 0) +SET (ASSIMP_VERSION_MAJOR ${PROJECT_VERSION_MAJOR}) +SET (ASSIMP_VERSION_MINOR ${PROJECT_VERSION_MINOR}) +SET (ASSIMP_VERSION_PATCH ${PROJECT_VERSION_PATCH}) SET (ASSIMP_VERSION ${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH}) -SET (ASSIMP_SOVERSION 4) -SET (PROJECT_VERSION "${ASSIMP_VERSION}") +SET (ASSIMP_SOVERSION 5) SET( ASSIMP_PACKAGE_VERSION "0" CACHE STRING "the package-specific version used for uploading the sources" ) -# Enable C++11 support globally -set_property( GLOBAL PROPERTY CXX_STANDARD 11 ) +if(NOT HUNTER_ENABLED) + # Enable C++11 support globally + set_property( GLOBAL PROPERTY CXX_STANDARD 11 ) +endif() IF(NOT IGNORE_GIT_HASH) # Get the current working branch @@ -203,6 +219,7 @@ CONFIGURE_FILE( INCLUDE_DIRECTORIES( BEFORE ./ + code/ include ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/include @@ -221,9 +238,13 @@ ENDIF( UNIX ) # Grouped compiler settings IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT CMAKE_COMPILER_IS_MINGW) + IF(NOT HUNTER_ENABLED) + SET(CMAKE_CXX_FLAGS "-fPIC -std=c++0x ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}") + ENDIF() # hide all not-exported symbols - SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -std=c++0x ${CMAKE_CXX_FLAGS}") - SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}") + SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}") SET(LIBSTDC++_LIBRARIES -lstdc++) ELSEIF(MSVC) # enable multi-core compilation with MSVC @@ -234,20 +255,28 @@ ELSEIF(MSVC) ADD_COMPILE_OPTIONS(/wd4351) ENDIF() ELSEIF ( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" ) - SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 ${CMAKE_CXX_FLAGS}" ) - SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}") + IF(NOT HUNTER_ENABLED) + SET(CMAKE_CXX_FLAGS "-fPIC -std=c++11 ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}") + ENDIF() + SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long ${CMAKE_CXX_FLAGS}" ) + SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}") ELSEIF( CMAKE_COMPILER_IS_MINGW ) IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0) message(FATAL_ERROR "MinGW is too old to be supported. Please update MinGW and try again.") ELSEIF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.3) message(WARNING "MinGW is old, if you experience errors, update MinGW.") ENDIF() - SET( CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 -Wa,-mbig-obj ${CMAKE_CXX_FLAGS}" ) - SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS} ") + IF(NOT HUNTER_ENABLED) + SET(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}") + ENDIF() + SET(CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -Wa,-mbig-obj ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS "-fno-strict-aliasing ${CMAKE_C_FLAGS}") ADD_DEFINITIONS( -U__STRICT_ANSI__ ) ENDIF() -IF ( IOS ) +IF ( IOS AND NOT HUNTER_ENABLED) IF (CMAKE_BUILD_TYPE STREQUAL "Debug") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fembed-bitcode -Og") @@ -258,7 +287,7 @@ ELSE() # Experimental for pdb generation ENDIF() -ENDIF( IOS ) +ENDIF( IOS AND NOT HUNTER_ENABLED) IF (ASSIMP_COVERALLS) MESSAGE(STATUS "Coveralls enabled") @@ -325,20 +354,67 @@ IF (NOT TARGET uninstall) ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake") ENDIF() -# cmake configuration files -CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" @ONLY IMMEDIATE) -CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake" @ONLY IMMEDIATE) -CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-debug.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake" @ONLY IMMEDIATE) -CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-release.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake" @ONLY IMMEDIATE) -CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config-version.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake" @ONLY IMMEDIATE) -#we should generated these scripts after CMake VERSION 3.0.2 using export(EXPORT ...) and write_basic_package_version_file(...) -INSTALL(FILES - "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" - "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake" - "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake" - "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake" - "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake" - DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT}) +IF(HUNTER_ENABLED) + set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}") + set(INCLUDE_INSTALL_DIR "include") + + set(GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated") + + # Configuration + set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake") + set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake") + set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets") + set(NAMESPACE "${PROJECT_NAME}::") + + # Include module with fuction 'write_basic_package_version_file' + include(CMakePackageConfigHelpers) + + # Note: PROJECT_VERSION is used as a VERSION + write_basic_package_version_file("${VERSION_CONFIG}" COMPATIBILITY SameMajorVersion) + + # Use variables: + # * TARGETS_EXPORT_NAME + # * PROJECT_NAME + configure_package_config_file( + "cmake/assimp-hunter-config.cmake.in" + "${PROJECT_CONFIG}" + INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}" + ) + + install( + FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}" + DESTINATION "${CONFIG_INSTALL_DIR}" + ) + + install( + EXPORT "${TARGETS_EXPORT_NAME}" + NAMESPACE "${NAMESPACE}" + DESTINATION "${CONFIG_INSTALL_DIR}" + ) +ELSE(HUNTER_ENABLED) + # cmake configuration files + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" @ONLY IMMEDIATE) + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake" @ONLY IMMEDIATE) + IF (is_multi_config) + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-debug.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake" @ONLY IMMEDIATE) + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-release.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake" @ONLY IMMEDIATE) + SET(PACKAGE_TARGETS_FILE "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake") + ELSEIF (CMAKE_BUILD_TYPE STREQUAL Debug) + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-debug.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake" @ONLY IMMEDIATE) + SET(PACKAGE_TARGETS_FILE "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake") + ELSE() + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-release.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake" @ONLY IMMEDIATE) + SET(PACKAGE_TARGETS_FILE "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake") + ENDIF() + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config-version.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake" @ONLY IMMEDIATE) + #we should generated these scripts after CMake VERSION 3.0.2 using export(EXPORT ...) and write_basic_package_version_file(...) + INSTALL(FILES + "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake" + ${PACKAGE_TARGETS_FILE} + DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT}) +ENDIF(HUNTER_ENABLED) FIND_PACKAGE( DirectX ) @@ -353,48 +429,57 @@ ENDIF( SYSTEM_IRRXML ) # Search for external dependencies, and build them from source if not found # Search for zlib -IF ( NOT ASSIMP_BUILD_ZLIB ) - FIND_PACKAGE(ZLIB) -ENDIF( NOT ASSIMP_BUILD_ZLIB ) +IF(HUNTER_ENABLED) + hunter_add_package(ZLIB) + find_package(ZLIB CONFIG REQUIRED) -IF( NOT ZLIB_FOUND ) - MESSAGE(STATUS "compiling zlib from sources") - INCLUDE(CheckIncludeFile) - INCLUDE(CheckTypeSize) - INCLUDE(CheckFunctionExists) + add_definitions(-DASSIMP_BUILD_NO_OWN_ZLIB) + set(ZLIB_FOUND TRUE) + set(ZLIB_LIBRARIES ZLIB::zlib) + set(ASSIMP_BUILD_MINIZIP TRUE) +ELSE(HUNTER_ENABLED) + IF ( NOT ASSIMP_BUILD_ZLIB ) + FIND_PACKAGE(ZLIB) + ENDIF( NOT ASSIMP_BUILD_ZLIB ) - # Explicitly turn off ASM686 and AMD64 cmake options. - # The AMD64 option causes a build failure on MSVC and the ASM builds seem to have problems: - # https://github.com/madler/zlib/issues/41#issuecomment-125848075 - # Also prevents these options from "polluting" the cmake options if assimp is being - # included as a submodule. - set( ASM686 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE ) - set( AMD64 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE ) + IF( NOT ZLIB_FOUND ) + MESSAGE(STATUS "compiling zlib from sources") + INCLUDE(CheckIncludeFile) + INCLUDE(CheckTypeSize) + INCLUDE(CheckFunctionExists) - # compile from sources - ADD_SUBDIRECTORY(contrib/zlib) - SET(ZLIB_FOUND 1) - SET(ZLIB_LIBRARIES zlibstatic) - SET(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/contrib/zlib ${CMAKE_CURRENT_BINARY_DIR}/contrib/zlib) - # need to ensure we don't link with system zlib or minizip as well. - SET(ASSIMP_BUILD_MINIZIP 1) -ELSE(NOT ZLIB_FOUND) - ADD_DEFINITIONS(-DASSIMP_BUILD_NO_OWN_ZLIB) - SET(ZLIB_LIBRARIES_LINKED -lz) -ENDIF(NOT ZLIB_FOUND) -INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR}) + # Explicitly turn off ASM686 and AMD64 cmake options. + # The AMD64 option causes a build failure on MSVC and the ASM builds seem to have problems: + # https://github.com/madler/zlib/issues/41#issuecomment-125848075 + # Also prevents these options from "polluting" the cmake options if assimp is being + # included as a submodule. + set( ASM686 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE ) + set( AMD64 FALSE CACHE INTERNAL "Override ZLIB flag to turn off assembly" FORCE ) -# Search for unzip -IF ( NOT IOS ) + # compile from sources + ADD_SUBDIRECTORY(contrib/zlib) + SET(ZLIB_FOUND 1) + SET(ZLIB_LIBRARIES zlibstatic) + SET(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/contrib/zlib ${CMAKE_CURRENT_BINARY_DIR}/contrib/zlib) + # need to ensure we don't link with system zlib or minizip as well. + SET(ASSIMP_BUILD_MINIZIP 1) + ELSE(NOT ZLIB_FOUND) + ADD_DEFINITIONS(-DASSIMP_BUILD_NO_OWN_ZLIB) + SET(ZLIB_LIBRARIES_LINKED -lz) + ENDIF(NOT ZLIB_FOUND) + INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR}) +ENDIF(HUNTER_ENABLED) + +IF( NOT IOS ) IF( NOT ASSIMP_BUILD_MINIZIP ) - use_pkgconfig(UNZIP minizip) + use_pkgconfig(UNZIP minizip) ENDIF( NOT ASSIMP_BUILD_MINIZIP ) ELSE ( NOT IOS ) - IF(NOT BUILD_SHARED_LIBS) + IF( NOT BUILD_SHARED_LIBS ) IF( NOT ASSIMP_BUILD_MINIZIP ) - use_pkgconfig(UNZIP minizip) + use_pkgconfig(UNZIP minizip) ENDIF( NOT ASSIMP_BUILD_MINIZIP ) - ENDIF (NOT BUILD_SHARED_LIBS) + ENDIF ( NOT BUILD_SHARED_LIBS ) ENDIF ( NOT IOS ) IF ( ASSIMP_NO_EXPORT ) @@ -468,7 +553,9 @@ ELSE (ASSIMP_BUILD_NONFREE_C4D_IMPORTER) ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER ) ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER) -ADD_SUBDIRECTORY(contrib) +IF(NOT HUNTER_ENABLED) + ADD_SUBDIRECTORY(contrib) +ENDIF(NOT HUNTER_ENABLED) ADD_SUBDIRECTORY( code/ ) IF ( ASSIMP_BUILD_ASSIMP_TOOLS ) diff --git a/Readme.md b/Readme.md index 19e43a3cb..52a195a64 100644 --- a/Readme.md +++ b/Readme.md @@ -125,7 +125,7 @@ Take a look into the https://github.com/assimp/assimp/blob/master/Build.md file. ### Ports ### * [Android](port/AndroidJNI/README.md) * [Python](port/PyAssimp/README.md) -* [.NET](port/AssimpNET/Readme.md) +* [.NET](https://github.com/kebby/assimp-net) * [Pascal](port/AssimpPascal/Readme.md) * [Javascript (Alpha)](https://github.com/makc/assimp2json) * [Unity 3d Plugin](https://www.assetstore.unity3d.com/en/#!/content/91777) @@ -136,7 +136,7 @@ Take a look into the https://github.com/assimp/assimp/blob/master/Build.md file. [open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities. #### Repository structure #### -Open Asset Import Library is implemented in C++. The directory structure is: +Open Asset Import Library is implemented in C++. The directory structure looks like: /code Source code /contrib Third-party libraries @@ -149,6 +149,11 @@ Open Asset Import Library is implemented in C++. The directory structure is: /samples A small number of samples to illustrate possible use cases for Assimp +The source code is organized in the following way: + + code/Common The base implementation for importers and the infrastructure + code/PostProcessing The post-processing steps + code/ Implementation for import and export for the format ### Where to get help ### For more information, visit [our website](http://assimp.org/). Or check out the `./doc`- folder, which contains the official documentation in HTML format. diff --git a/assimpTargets-debug.cmake.in b/assimpTargets-debug.cmake.in index a83e6c22d..1ebe2a608 100644 --- a/assimpTargets-debug.cmake.in +++ b/assimpTargets-debug.cmake.in @@ -5,48 +5,79 @@ # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) +set(ASSIMP_BUILD_SHARED_LIBS @BUILD_SHARED_LIBS@) + if(MSVC) - if( MSVC70 OR MSVC71 ) - set(MSVC_PREFIX "vc70") - elseif( MSVC80 ) - set(MSVC_PREFIX "vc80") - elseif( MSVC90 ) - set(MSVC_PREFIX "vc90") - elseif( MSVC10 ) - set(MSVC_PREFIX "vc100") - elseif( MSVC11 ) - set(MSVC_PREFIX "vc110") - elseif( MSVC12 ) - set(MSVC_PREFIX "vc120") - elseif( MSVC14 ) - set(MSVC_PREFIX "vc140") + if(MSVC_TOOLSET_VERSION) + set(MSVC_PREFIX "vc${MSVC_TOOLSET_VERSION}") else() - set(MSVC_PREFIX "vc150") + if( MSVC70 OR MSVC71 ) + set(MSVC_PREFIX "vc70") + elseif( MSVC80 ) + set(MSVC_PREFIX "vc80") + elseif( MSVC90 ) + set(MSVC_PREFIX "vc90") + elseif( MSVC10 ) + set(MSVC_PREFIX "vc100") + elseif( MSVC11 ) + set(MSVC_PREFIX "vc110") + elseif( MSVC12 ) + set(MSVC_PREFIX "vc120") + elseif( MSVC_VERSION LESS 1910) + set(MSVC_PREFIX "vc140") + elseif( MSVC_VERSION LESS 1920) + set(MSVC_PREFIX "vc141") + elseif( MSVC_VERSION LESS 1930) + set(MSVC_PREFIX "vc142") + else() + set(MSVC_PREFIX "vc150") + endif() endif() set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" ) - set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@") - set(importLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_IMPORT_LIBRARY_SUFFIX@") + if(ASSIMP_BUILD_SHARED_LIBS) + set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@") + set(importLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_IMPORT_LIBRARY_SUFFIX@") - # Import target "assimp::assimp" for configuration "Debug" - set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) - set_target_properties(assimp::assimp PROPERTIES - IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/${importLibraryName}" - IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" - ) - list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}") - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) + # Import target "assimp::assimp" for configuration "Debug" + set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/${importLibraryName}" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" + ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}") + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) + else() + set(staticLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_STATIC_LIBRARY_SUFFIX@") + + # Import target "assimp::assimp" for configuration "Debug" + set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}") + endif() else() - set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the openrave libraries" ) - set(sharedLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@.@ASSIMP_VERSION_MAJOR@") - set_target_properties(assimp::assimp PROPERTIES - IMPORTED_SONAME_DEBUG "${sharedLibraryName}" - IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" + set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the assimp libraries" ) + if(ASSIMP_BUILD_SHARED_LIBS) + set(sharedLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@.@ASSIMP_VERSION_MAJOR@") + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_SONAME_DEBUG "${sharedLibraryName}" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) - list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) + else() + set(staticLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_STATIC_LIBRARY_SUFFIX@") + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}" ) + endif() endif() @@ -60,7 +91,11 @@ set( ASSIMP_CXX_FLAGS ) # dynamically linked library set( ASSIMP_LINK_FLAGS "" ) set( ASSIMP_LIBRARY_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_LIB_INSTALL_DIR@") set( ASSIMP_INCLUDE_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_INCLUDE_INSTALL_DIR@") -set( ASSIMP_LIBRARIES ${sharedLibraryName}) +if(ASSIMP_BUILD_SHARED_LIBS) + set( ASSIMP_LIBRARIES ${sharedLibraryName}) +else() + set( ASSIMP_LIBRARIES ${staticLibraryName}) +endif() # for compatibility with pkg-config set(ASSIMP_CFLAGS_OTHER "${ASSIMP_CXX_FLAGS}") @@ -75,4 +110,5 @@ MARK_AS_ADVANCED( ASSIMP_CFLAGS_OTHER ASSIMP_LDFLAGS_OTHER ASSIMP_LIBRARY_SUFFIX + ASSIMP_BUILD_SHARED_LIBS ) diff --git a/assimpTargets-release.cmake.in b/assimpTargets-release.cmake.in index 2efae448a..b09b881f7 100644 --- a/assimpTargets-release.cmake.in +++ b/assimpTargets-release.cmake.in @@ -5,48 +5,79 @@ # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) +set(ASSIMP_BUILD_SHARED_LIBS @BUILD_SHARED_LIBS@) + if(MSVC) - if( MSVC70 OR MSVC71 ) - set(MSVC_PREFIX "vc70") - elseif( MSVC80 ) - set(MSVC_PREFIX "vc80") - elseif( MSVC90 ) - set(MSVC_PREFIX "vc90") - elseif( MSVC10 ) - set(MSVC_PREFIX "vc100") - elseif( MSVC11 ) - set(MSVC_PREFIX "vc110") - elseif( MSVC12 ) - set(MSVC_PREFIX "vc120") - elseif( MSVC14 ) - set(MSVC_PREFIX "vc140") + if(MSVC_TOOLSET_VERSION) + set(MSVC_PREFIX "vc${MSVC_TOOLSET_VERSION}") else() - set(MSVC_PREFIX "vc150") + if( MSVC70 OR MSVC71 ) + set(MSVC_PREFIX "vc70") + elseif( MSVC80 ) + set(MSVC_PREFIX "vc80") + elseif( MSVC90 ) + set(MSVC_PREFIX "vc90") + elseif( MSVC10 ) + set(MSVC_PREFIX "vc100") + elseif( MSVC11 ) + set(MSVC_PREFIX "vc110") + elseif( MSVC12 ) + set(MSVC_PREFIX "vc120") + elseif( MSVC_VERSION LESS 1910) + set(MSVC_PREFIX "vc140") + elseif( MSVC_VERSION LESS 1920) + set(MSVC_PREFIX "vc141") + elseif( MSVC_VERSION LESS 1930) + set(MSVC_PREFIX "vc142") + else() + set(MSVC_PREFIX "vc150") + endif() endif() set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" ) - set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@") - set(importLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_IMPORT_LIBRARY_SUFFIX@") + if(ASSIMP_BUILD_SHARED_LIBS) + set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@") + set(importLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_IMPORT_LIBRARY_SUFFIX@") - # Import target "assimp::assimp" for configuration "Release" - set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) - set_target_properties(assimp::assimp PROPERTIES - IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/${importLibraryName}" - IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" + # Import target "assimp::assimp" for configuration "Release" + set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/${importLibraryName}" + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) - list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}") - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}") + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) + else() + set(staticLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_STATIC_LIBRARY_SUFFIX@") + + # Import target "assimp::assimp" for configuration "Release" + set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}") + endif() else() - set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the openrave libraries" ) - set(sharedLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@.@ASSIMP_VERSION_MAJOR@") - set_target_properties(assimp::assimp PROPERTIES - IMPORTED_SONAME_RELEASE "${sharedLibraryName}" - IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" + set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the assimp libraries" ) + if(ASSIMP_BUILD_SHARED_LIBS) + set(sharedLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@.@ASSIMP_VERSION_MAJOR@") + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_SONAME_RELEASE "${sharedLibraryName}" + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) - list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) + else() + set(staticLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_STATIC_LIBRARY_SUFFIX@") + set_target_properties(assimp::assimp PROPERTIES + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + ) + list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}" ) + endif() endif() # Commands beyond this point should not need to know the version. @@ -58,7 +89,11 @@ set( ASSIMP_CXX_FLAGS ) # dynamically linked library set( ASSIMP_LINK_FLAGS "" ) set( ASSIMP_LIBRARY_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_LIB_INSTALL_DIR@") set( ASSIMP_INCLUDE_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_INCLUDE_INSTALL_DIR@") -set( ASSIMP_LIBRARIES ${sharedLibraryName}) +if(ASSIMP_BUILD_SHARED_LIBS) + set( ASSIMP_LIBRARIES ${sharedLibraryName}) +else() + set( ASSIMP_LIBRARIES ${staticLibraryName}) +endif() # for compatibility with pkg-config set(ASSIMP_CFLAGS_OTHER "${ASSIMP_CXX_FLAGS}") @@ -73,4 +108,5 @@ MARK_AS_ADVANCED( ASSIMP_CFLAGS_OTHER ASSIMP_LDFLAGS_OTHER ASSIMP_LIBRARY_SUFFIX + ASSIMP_BUILD_SHARED_LIBS ) diff --git a/assimpTargets.cmake.in b/assimpTargets.cmake.in index 68e2c0dec..ab1a8d2c7 100644 --- a/assimpTargets.cmake.in +++ b/assimpTargets.cmake.in @@ -51,7 +51,11 @@ if(_IMPORT_PREFIX STREQUAL "/") endif() # Create imported target assimp::assimp -add_library(assimp::assimp SHARED IMPORTED) +if(@BUILD_SHARED_LIBS@) + add_library(assimp::assimp SHARED IMPORTED) +else() + add_library(assimp::assimp STATIC IMPORTED) +endif() set_target_properties(assimp::assimp PROPERTIES COMPATIBLE_INTERFACE_STRING "assimp_MAJOR_VERSION" diff --git a/cmake/HunterGate.cmake b/cmake/HunterGate.cmake new file mode 100644 index 000000000..887557a58 --- /dev/null +++ b/cmake/HunterGate.cmake @@ -0,0 +1,540 @@ +# Copyright (c) 2013-2018, Ruslan Baratov +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# This is a gate file to Hunter package manager. +# Include this file using `include` command and add package you need, example: +# +# cmake_minimum_required(VERSION 3.2) +# +# include("cmake/HunterGate.cmake") +# HunterGate( +# URL "https://github.com/path/to/hunter/archive.tar.gz" +# SHA1 "798501e983f14b28b10cda16afa4de69eee1da1d" +# ) +# +# project(MyProject) +# +# hunter_add_package(Foo) +# hunter_add_package(Boo COMPONENTS Bar Baz) +# +# Projects: +# * https://github.com/hunter-packages/gate/ +# * https://github.com/ruslo/hunter + +option(HUNTER_ENABLED "Enable Hunter package manager support" ON) + +if(HUNTER_ENABLED) + if(CMAKE_VERSION VERSION_LESS "3.2") + message( + FATAL_ERROR + "At least CMake version 3.2 required for Hunter dependency management." + " Update CMake or set HUNTER_ENABLED to OFF." + ) + endif() +endif() + +include(CMakeParseArguments) # cmake_parse_arguments + +option(HUNTER_STATUS_PRINT "Print working status" ON) +option(HUNTER_STATUS_DEBUG "Print a lot info" OFF) +option(HUNTER_TLS_VERIFY "Enable/disable TLS certificate checking on downloads" ON) + +set(HUNTER_WIKI "https://github.com/ruslo/hunter/wiki") + +function(hunter_gate_status_print) + if(HUNTER_STATUS_PRINT OR HUNTER_STATUS_DEBUG) + foreach(print_message ${ARGV}) + message(STATUS "[hunter] ${print_message}") + endforeach() + endif() +endfunction() + +function(hunter_gate_status_debug) + if(HUNTER_STATUS_DEBUG) + foreach(print_message ${ARGV}) + string(TIMESTAMP timestamp) + message(STATUS "[hunter *** DEBUG *** ${timestamp}] ${print_message}") + endforeach() + endif() +endfunction() + +function(hunter_gate_wiki wiki_page) + message("------------------------------ WIKI -------------------------------") + message(" ${HUNTER_WIKI}/${wiki_page}") + message("-------------------------------------------------------------------") + message("") + message(FATAL_ERROR "") +endfunction() + +function(hunter_gate_internal_error) + message("") + foreach(print_message ${ARGV}) + message("[hunter ** INTERNAL **] ${print_message}") + endforeach() + message("[hunter ** INTERNAL **] [Directory:${CMAKE_CURRENT_LIST_DIR}]") + message("") + hunter_gate_wiki("error.internal") +endfunction() + +function(hunter_gate_fatal_error) + cmake_parse_arguments(hunter "" "WIKI" "" "${ARGV}") + string(COMPARE EQUAL "${hunter_WIKI}" "" have_no_wiki) + if(have_no_wiki) + hunter_gate_internal_error("Expected wiki") + endif() + message("") + foreach(x ${hunter_UNPARSED_ARGUMENTS}) + message("[hunter ** FATAL ERROR **] ${x}") + endforeach() + message("[hunter ** FATAL ERROR **] [Directory:${CMAKE_CURRENT_LIST_DIR}]") + message("") + hunter_gate_wiki("${hunter_WIKI}") +endfunction() + +function(hunter_gate_user_error) + hunter_gate_fatal_error(${ARGV} WIKI "error.incorrect.input.data") +endfunction() + +function(hunter_gate_self root version sha1 result) + string(COMPARE EQUAL "${root}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("root is empty") + endif() + + string(COMPARE EQUAL "${version}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("version is empty") + endif() + + string(COMPARE EQUAL "${sha1}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("sha1 is empty") + endif() + + string(SUBSTRING "${sha1}" 0 7 archive_id) + + if(EXISTS "${root}/cmake/Hunter") + set(hunter_self "${root}") + else() + set( + hunter_self + "${root}/_Base/Download/Hunter/${version}/${archive_id}/Unpacked" + ) + endif() + + set("${result}" "${hunter_self}" PARENT_SCOPE) +endfunction() + +# Set HUNTER_GATE_ROOT cmake variable to suitable value. +function(hunter_gate_detect_root) + # Check CMake variable + string(COMPARE NOTEQUAL "${HUNTER_ROOT}" "" not_empty) + if(not_empty) + set(HUNTER_GATE_ROOT "${HUNTER_ROOT}" PARENT_SCOPE) + hunter_gate_status_debug("HUNTER_ROOT detected by cmake variable") + return() + endif() + + # Check environment variable + string(COMPARE NOTEQUAL "$ENV{HUNTER_ROOT}" "" not_empty) + if(not_empty) + set(HUNTER_GATE_ROOT "$ENV{HUNTER_ROOT}" PARENT_SCOPE) + hunter_gate_status_debug("HUNTER_ROOT detected by environment variable") + return() + endif() + + # Check HOME environment variable + string(COMPARE NOTEQUAL "$ENV{HOME}" "" result) + if(result) + set(HUNTER_GATE_ROOT "$ENV{HOME}/.hunter" PARENT_SCOPE) + hunter_gate_status_debug("HUNTER_ROOT set using HOME environment variable") + return() + endif() + + # Check SYSTEMDRIVE and USERPROFILE environment variable (windows only) + if(WIN32) + string(COMPARE NOTEQUAL "$ENV{SYSTEMDRIVE}" "" result) + if(result) + set(HUNTER_GATE_ROOT "$ENV{SYSTEMDRIVE}/.hunter" PARENT_SCOPE) + hunter_gate_status_debug( + "HUNTER_ROOT set using SYSTEMDRIVE environment variable" + ) + return() + endif() + + string(COMPARE NOTEQUAL "$ENV{USERPROFILE}" "" result) + if(result) + set(HUNTER_GATE_ROOT "$ENV{USERPROFILE}/.hunter" PARENT_SCOPE) + hunter_gate_status_debug( + "HUNTER_ROOT set using USERPROFILE environment variable" + ) + return() + endif() + endif() + + hunter_gate_fatal_error( + "Can't detect HUNTER_ROOT" + WIKI "error.detect.hunter.root" + ) +endfunction() + +function(hunter_gate_download dir) + string( + COMPARE + NOTEQUAL + "$ENV{HUNTER_DISABLE_AUTOINSTALL}" + "" + disable_autoinstall + ) + if(disable_autoinstall AND NOT HUNTER_RUN_INSTALL) + hunter_gate_fatal_error( + "Hunter not found in '${dir}'" + "Set HUNTER_RUN_INSTALL=ON to auto-install it from '${HUNTER_GATE_URL}'" + "Settings:" + " HUNTER_ROOT: ${HUNTER_GATE_ROOT}" + " HUNTER_SHA1: ${HUNTER_GATE_SHA1}" + WIKI "error.run.install" + ) + endif() + string(COMPARE EQUAL "${dir}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("Empty 'dir' argument") + endif() + + string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("HUNTER_GATE_SHA1 empty") + endif() + + string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("HUNTER_GATE_URL empty") + endif() + + set(done_location "${dir}/DONE") + set(sha1_location "${dir}/SHA1") + + set(build_dir "${dir}/Build") + set(cmakelists "${dir}/CMakeLists.txt") + + hunter_gate_status_debug("Locking directory: ${dir}") + file(LOCK "${dir}" DIRECTORY GUARD FUNCTION) + hunter_gate_status_debug("Lock done") + + if(EXISTS "${done_location}") + # while waiting for lock other instance can do all the job + hunter_gate_status_debug("File '${done_location}' found, skip install") + return() + endif() + + file(REMOVE_RECURSE "${build_dir}") + file(REMOVE_RECURSE "${cmakelists}") + + file(MAKE_DIRECTORY "${build_dir}") # check directory permissions + + # Disabling languages speeds up a little bit, reduces noise in the output + # and avoids path too long windows error + file( + WRITE + "${cmakelists}" + "cmake_minimum_required(VERSION 3.2)\n" + "project(HunterDownload LANGUAGES NONE)\n" + "include(ExternalProject)\n" + "ExternalProject_Add(\n" + " Hunter\n" + " URL\n" + " \"${HUNTER_GATE_URL}\"\n" + " URL_HASH\n" + " SHA1=${HUNTER_GATE_SHA1}\n" + " DOWNLOAD_DIR\n" + " \"${dir}\"\n" + " TLS_VERIFY\n" + " ${HUNTER_TLS_VERIFY}\n" + " SOURCE_DIR\n" + " \"${dir}/Unpacked\"\n" + " CONFIGURE_COMMAND\n" + " \"\"\n" + " BUILD_COMMAND\n" + " \"\"\n" + " INSTALL_COMMAND\n" + " \"\"\n" + ")\n" + ) + + if(HUNTER_STATUS_DEBUG) + set(logging_params "") + else() + set(logging_params OUTPUT_QUIET) + endif() + + hunter_gate_status_debug("Run generate") + + # Need to add toolchain file too. + # Otherwise on Visual Studio + MDD this will fail with error: + # "Could not find an appropriate version of the Windows 10 SDK installed on this machine" + if(EXISTS "${CMAKE_TOOLCHAIN_FILE}") + get_filename_component(absolute_CMAKE_TOOLCHAIN_FILE "${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE) + set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${absolute_CMAKE_TOOLCHAIN_FILE}") + else() + # 'toolchain_arg' can't be empty + set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=") + endif() + + string(COMPARE EQUAL "${CMAKE_MAKE_PROGRAM}" "" no_make) + if(no_make) + set(make_arg "") + else() + # Test case: remove Ninja from PATH but set it via CMAKE_MAKE_PROGRAM + set(make_arg "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}") + endif() + + execute_process( + COMMAND + "${CMAKE_COMMAND}" + "-H${dir}" + "-B${build_dir}" + "-G${CMAKE_GENERATOR}" + "${toolchain_arg}" + ${make_arg} + WORKING_DIRECTORY "${dir}" + RESULT_VARIABLE download_result + ${logging_params} + ) + + if(NOT download_result EQUAL 0) + hunter_gate_internal_error( + "Configure project failed." + "To reproduce the error run: ${CMAKE_COMMAND} -H${dir} -B${build_dir} -G${CMAKE_GENERATOR} ${toolchain_arg} ${make_arg}" + "In directory ${dir}" + ) + endif() + + hunter_gate_status_print( + "Initializing Hunter workspace (${HUNTER_GATE_SHA1})" + " ${HUNTER_GATE_URL}" + " -> ${dir}" + ) + execute_process( + COMMAND "${CMAKE_COMMAND}" --build "${build_dir}" + WORKING_DIRECTORY "${dir}" + RESULT_VARIABLE download_result + ${logging_params} + ) + + if(NOT download_result EQUAL 0) + hunter_gate_internal_error("Build project failed") + endif() + + file(REMOVE_RECURSE "${build_dir}") + file(REMOVE_RECURSE "${cmakelists}") + + file(WRITE "${sha1_location}" "${HUNTER_GATE_SHA1}") + file(WRITE "${done_location}" "DONE") + + hunter_gate_status_debug("Finished") +endfunction() + +# Must be a macro so master file 'cmake/Hunter' can +# apply all variables easily just by 'include' command +# (otherwise PARENT_SCOPE magic needed) +macro(HunterGate) + if(HUNTER_GATE_DONE) + # variable HUNTER_GATE_DONE set explicitly for external project + # (see `hunter_download`) + set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES) + endif() + + # First HunterGate command will init Hunter, others will be ignored + get_property(_hunter_gate_done GLOBAL PROPERTY HUNTER_GATE_DONE SET) + + if(NOT HUNTER_ENABLED) + # Empty function to avoid error "unknown function" + function(hunter_add_package) + endfunction() + + set( + _hunter_gate_disabled_mode_dir + "${CMAKE_CURRENT_LIST_DIR}/cmake/Hunter/disabled-mode" + ) + if(EXISTS "${_hunter_gate_disabled_mode_dir}") + hunter_gate_status_debug( + "Adding \"disabled-mode\" modules: ${_hunter_gate_disabled_mode_dir}" + ) + list(APPEND CMAKE_PREFIX_PATH "${_hunter_gate_disabled_mode_dir}") + endif() + elseif(_hunter_gate_done) + hunter_gate_status_debug("Secondary HunterGate (use old settings)") + hunter_gate_self( + "${HUNTER_CACHED_ROOT}" + "${HUNTER_VERSION}" + "${HUNTER_SHA1}" + _hunter_self + ) + include("${_hunter_self}/cmake/Hunter") + else() + set(HUNTER_GATE_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}") + + string(COMPARE NOTEQUAL "${PROJECT_NAME}" "" _have_project_name) + if(_have_project_name) + hunter_gate_fatal_error( + "Please set HunterGate *before* 'project' command. " + "Detected project: ${PROJECT_NAME}" + WIKI "error.huntergate.before.project" + ) + endif() + + cmake_parse_arguments( + HUNTER_GATE "LOCAL" "URL;SHA1;GLOBAL;FILEPATH" "" ${ARGV} + ) + + string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" _empty_sha1) + string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" _empty_url) + string( + COMPARE + NOTEQUAL + "${HUNTER_GATE_UNPARSED_ARGUMENTS}" + "" + _have_unparsed + ) + string(COMPARE NOTEQUAL "${HUNTER_GATE_GLOBAL}" "" _have_global) + string(COMPARE NOTEQUAL "${HUNTER_GATE_FILEPATH}" "" _have_filepath) + + if(_have_unparsed) + hunter_gate_user_error( + "HunterGate unparsed arguments: ${HUNTER_GATE_UNPARSED_ARGUMENTS}" + ) + endif() + if(_empty_sha1) + hunter_gate_user_error("SHA1 suboption of HunterGate is mandatory") + endif() + if(_empty_url) + hunter_gate_user_error("URL suboption of HunterGate is mandatory") + endif() + if(_have_global) + if(HUNTER_GATE_LOCAL) + hunter_gate_user_error("Unexpected LOCAL (already has GLOBAL)") + endif() + if(_have_filepath) + hunter_gate_user_error("Unexpected FILEPATH (already has GLOBAL)") + endif() + endif() + if(HUNTER_GATE_LOCAL) + if(_have_global) + hunter_gate_user_error("Unexpected GLOBAL (already has LOCAL)") + endif() + if(_have_filepath) + hunter_gate_user_error("Unexpected FILEPATH (already has LOCAL)") + endif() + endif() + if(_have_filepath) + if(_have_global) + hunter_gate_user_error("Unexpected GLOBAL (already has FILEPATH)") + endif() + if(HUNTER_GATE_LOCAL) + hunter_gate_user_error("Unexpected LOCAL (already has FILEPATH)") + endif() + endif() + + hunter_gate_detect_root() # set HUNTER_GATE_ROOT + + # Beautify path, fix probable problems with windows path slashes + get_filename_component( + HUNTER_GATE_ROOT "${HUNTER_GATE_ROOT}" ABSOLUTE + ) + hunter_gate_status_debug("HUNTER_ROOT: ${HUNTER_GATE_ROOT}") + if(NOT HUNTER_ALLOW_SPACES_IN_PATH) + string(FIND "${HUNTER_GATE_ROOT}" " " _contain_spaces) + if(NOT _contain_spaces EQUAL -1) + hunter_gate_fatal_error( + "HUNTER_ROOT (${HUNTER_GATE_ROOT}) contains spaces." + "Set HUNTER_ALLOW_SPACES_IN_PATH=ON to skip this error" + "(Use at your own risk!)" + WIKI "error.spaces.in.hunter.root" + ) + endif() + endif() + + string( + REGEX + MATCH + "[0-9]+\\.[0-9]+\\.[0-9]+[-_a-z0-9]*" + HUNTER_GATE_VERSION + "${HUNTER_GATE_URL}" + ) + string(COMPARE EQUAL "${HUNTER_GATE_VERSION}" "" _is_empty) + if(_is_empty) + set(HUNTER_GATE_VERSION "unknown") + endif() + + hunter_gate_self( + "${HUNTER_GATE_ROOT}" + "${HUNTER_GATE_VERSION}" + "${HUNTER_GATE_SHA1}" + _hunter_self + ) + + set(_master_location "${_hunter_self}/cmake/Hunter") + if(EXISTS "${HUNTER_GATE_ROOT}/cmake/Hunter") + # Hunter downloaded manually (e.g. by 'git clone') + set(_unused "xxxxxxxxxx") + set(HUNTER_GATE_SHA1 "${_unused}") + set(HUNTER_GATE_VERSION "${_unused}") + else() + get_filename_component(_archive_id_location "${_hunter_self}/.." ABSOLUTE) + set(_done_location "${_archive_id_location}/DONE") + set(_sha1_location "${_archive_id_location}/SHA1") + + # Check Hunter already downloaded by HunterGate + if(NOT EXISTS "${_done_location}") + hunter_gate_download("${_archive_id_location}") + endif() + + if(NOT EXISTS "${_done_location}") + hunter_gate_internal_error("hunter_gate_download failed") + endif() + + if(NOT EXISTS "${_sha1_location}") + hunter_gate_internal_error("${_sha1_location} not found") + endif() + file(READ "${_sha1_location}" _sha1_value) + string(COMPARE EQUAL "${_sha1_value}" "${HUNTER_GATE_SHA1}" _is_equal) + if(NOT _is_equal) + hunter_gate_internal_error( + "Short SHA1 collision:" + " ${_sha1_value} (from ${_sha1_location})" + " ${HUNTER_GATE_SHA1} (HunterGate)" + ) + endif() + if(NOT EXISTS "${_master_location}") + hunter_gate_user_error( + "Master file not found:" + " ${_master_location}" + "try to update Hunter/HunterGate" + ) + endif() + endif() + include("${_master_location}") + set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES) + endif() +endmacro() diff --git a/cmake/assimp-hunter-config.cmake.in b/cmake/assimp-hunter-config.cmake.in new file mode 100644 index 000000000..34762ac54 --- /dev/null +++ b/cmake/assimp-hunter-config.cmake.in @@ -0,0 +1,14 @@ +@PACKAGE_INIT@ + +find_package(RapidJSON CONFIG REQUIRED) +find_package(ZLIB CONFIG REQUIRED) +find_package(utf8 CONFIG REQUIRED) +find_package(irrXML CONFIG REQUIRED) +find_package(minizip CONFIG REQUIRED) +find_package(openddlparser CONFIG REQUIRED) +find_package(poly2tri CONFIG REQUIRED) +find_package(polyclipping CONFIG REQUIRED) +find_package(zip CONFIG REQUIRED) + +include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake") +check_required_components("@PROJECT_NAME@") diff --git a/code/3DSConverter.cpp b/code/3DS/3DSConverter.cpp similarity index 99% rename from code/3DSConverter.cpp rename to code/3DS/3DSConverter.cpp index e6865a809..2176b75fc 100644 --- a/code/3DSConverter.cpp +++ b/code/3DS/3DSConverter.cpp @@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // internal headers #include "3DSLoader.h" -#include "TargetAnimation.h" +#include "Common/TargetAnimation.h" #include #include #include diff --git a/code/3DSExporter.cpp b/code/3DS/3DSExporter.cpp similarity index 99% rename from code/3DSExporter.cpp rename to code/3DS/3DSExporter.cpp index 2501d4049..1117a52ef 100644 --- a/code/3DSExporter.cpp +++ b/code/3DS/3DSExporter.cpp @@ -43,15 +43,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_3DS_EXPORTER -#include "3DSExporter.h" -#include "3DSLoader.h" -#include "3DSHelper.h" +#include "3DS/3DSExporter.h" +#include "3DS/3DSLoader.h" +#include "3DS/3DSHelper.h" +#include "PostProcessing/SplitLargeMeshes.h" + #include -#include "SplitLargeMeshes.h" #include #include #include #include + #include using namespace Assimp; diff --git a/code/3DSExporter.h b/code/3DS/3DSExporter.h similarity index 100% rename from code/3DSExporter.h rename to code/3DS/3DSExporter.h diff --git a/code/3DSHelper.h b/code/3DS/3DSHelper.h similarity index 100% rename from code/3DSHelper.h rename to code/3DS/3DSHelper.h diff --git a/code/3DSLoader.cpp b/code/3DS/3DSLoader.cpp similarity index 100% rename from code/3DSLoader.cpp rename to code/3DS/3DSLoader.cpp diff --git a/code/3DSLoader.h b/code/3DS/3DSLoader.h similarity index 100% rename from code/3DSLoader.h rename to code/3DS/3DSLoader.h diff --git a/code/3MFXmlTags.h b/code/3MF/3MFXmlTags.h similarity index 100% rename from code/3MFXmlTags.h rename to code/3MF/3MFXmlTags.h diff --git a/code/D3MFExporter.cpp b/code/3MF/D3MFExporter.cpp similarity index 99% rename from code/D3MFExporter.cpp rename to code/3MF/D3MFExporter.cpp index e8da91ba9..1f388ad3e 100644 --- a/code/D3MFExporter.cpp +++ b/code/3MF/D3MFExporter.cpp @@ -55,7 +55,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "3MFXmlTags.h" #include "D3MFOpcPackage.h" -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif namespace Assimp { diff --git a/code/D3MFExporter.h b/code/3MF/D3MFExporter.h similarity index 100% rename from code/D3MFExporter.h rename to code/3MF/D3MFExporter.h diff --git a/code/D3MFImporter.cpp b/code/3MF/D3MFImporter.cpp similarity index 99% rename from code/D3MFImporter.cpp rename to code/3MF/D3MFImporter.cpp index c218f4005..2898f8ac2 100644 --- a/code/D3MFImporter.cpp +++ b/code/3MF/D3MFImporter.cpp @@ -58,7 +58,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include "D3MFOpcPackage.h" -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif #include #include "3MFXmlTags.h" #include diff --git a/code/D3MFImporter.h b/code/3MF/D3MFImporter.h similarity index 100% rename from code/D3MFImporter.h rename to code/3MF/D3MFImporter.h diff --git a/code/D3MFOpcPackage.cpp b/code/3MF/D3MFOpcPackage.cpp similarity index 97% rename from code/D3MFOpcPackage.cpp rename to code/3MF/D3MFOpcPackage.cpp index aeadba5cc..3a6e4dbc9 100644 --- a/code/D3MFOpcPackage.cpp +++ b/code/3MF/D3MFOpcPackage.cpp @@ -56,7 +56,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif #include "3MFXmlTags.h" namespace Assimp { @@ -148,6 +152,15 @@ int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) { zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) { zlib_filefunc_def mapping; +#ifdef ASSIMP_USE_HUNTER + mapping.zopen_file = (open_file_func)open; + mapping.zread_file = (read_file_func)read; + mapping.zwrite_file = (write_file_func)write; + mapping.ztell_file = (tell_file_func)tell; + mapping.zseek_file = (seek_file_func)seek; + mapping.zclose_file = (close_file_func)close; + mapping.zerror_file = (error_file_func)testerror; +#else mapping.zopen_file = open; mapping.zread_file = read; mapping.zwrite_file = write; @@ -155,6 +168,7 @@ zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) { mapping.zseek_file = seek; mapping.zclose_file = close; mapping.zerror_file = testerror; +#endif mapping.opaque = reinterpret_cast(pIOHandler); return mapping; diff --git a/code/D3MFOpcPackage.h b/code/3MF/D3MFOpcPackage.h similarity index 100% rename from code/D3MFOpcPackage.h rename to code/3MF/D3MFOpcPackage.h diff --git a/code/ACLoader.cpp b/code/AC/ACLoader.cpp similarity index 99% rename from code/ACLoader.cpp rename to code/AC/ACLoader.cpp index 2eb839553..d4c4bd1a6 100644 --- a/code/ACLoader.cpp +++ b/code/AC/ACLoader.cpp @@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include "Importer.h" +#include "Common/Importer.h" #include #include #include diff --git a/code/ACLoader.h b/code/AC/ACLoader.h similarity index 100% rename from code/ACLoader.h rename to code/AC/ACLoader.h diff --git a/code/AMFImporter.cpp b/code/AMF/AMFImporter.cpp similarity index 100% rename from code/AMFImporter.cpp rename to code/AMF/AMFImporter.cpp diff --git a/code/AMFImporter.hpp b/code/AMF/AMFImporter.hpp similarity index 100% rename from code/AMFImporter.hpp rename to code/AMF/AMFImporter.hpp diff --git a/code/AMFImporter_Geometry.cpp b/code/AMF/AMFImporter_Geometry.cpp similarity index 100% rename from code/AMFImporter_Geometry.cpp rename to code/AMF/AMFImporter_Geometry.cpp diff --git a/code/AMFImporter_Macro.hpp b/code/AMF/AMFImporter_Macro.hpp similarity index 100% rename from code/AMFImporter_Macro.hpp rename to code/AMF/AMFImporter_Macro.hpp diff --git a/code/AMFImporter_Material.cpp b/code/AMF/AMFImporter_Material.cpp similarity index 100% rename from code/AMFImporter_Material.cpp rename to code/AMF/AMFImporter_Material.cpp diff --git a/code/AMFImporter_Node.hpp b/code/AMF/AMFImporter_Node.hpp similarity index 100% rename from code/AMFImporter_Node.hpp rename to code/AMF/AMFImporter_Node.hpp diff --git a/code/AMFImporter_Postprocess.cpp b/code/AMF/AMFImporter_Postprocess.cpp similarity index 100% rename from code/AMFImporter_Postprocess.cpp rename to code/AMF/AMFImporter_Postprocess.cpp diff --git a/code/ASELoader.cpp b/code/ASE/ASELoader.cpp similarity index 99% rename from code/ASELoader.cpp rename to code/ASE/ASELoader.cpp index 556e8ce66..8e99214a8 100644 --- a/code/ASELoader.cpp +++ b/code/ASE/ASELoader.cpp @@ -53,7 +53,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ASELoader.h" #include #include -#include "TargetAnimation.h" +#include "Common/TargetAnimation.h" + #include #include #include @@ -88,23 +89,25 @@ ASEImporter::ASEImporter() , mBuffer() , pcScene() , configRecomputeNormals() -, noSkeletonMesh() -{} +, noSkeletonMesh() { + // empty +} // ------------------------------------------------------------------------------------------------ // Destructor, private as well -ASEImporter::~ASEImporter() -{} +ASEImporter::~ASEImporter() { + // empty +} // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. -bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const -{ +bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const { // check file extension const std::string extension = GetExtension(pFile); - if( extension == "ase" || extension == "ask") + if (extension == "ase" || extension == "ask") { return true; + } if ((!extension.length() || cs) && pIOHandler) { const char* tokens[] = {"*3dsmax_asciiexport"}; @@ -115,15 +118,13 @@ bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool // ------------------------------------------------------------------------------------------------ // Loader meta information -const aiImporterDesc* ASEImporter::GetInfo () const -{ +const aiImporterDesc* ASEImporter::GetInfo () const { return &desc; } // ------------------------------------------------------------------------------------------------ // Setup configuration options -void ASEImporter::SetupProperties(const Importer* pImp) -{ +void ASEImporter::SetupProperties(const Importer* pImp) { configRecomputeNormals = (pImp->GetPropertyInteger( AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS,1) ? true : false); @@ -133,12 +134,11 @@ void ASEImporter::SetupProperties(const Importer* pImp) // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. void ASEImporter::InternReadFile( const std::string& pFile, - aiScene* pScene, IOSystem* pIOHandler) -{ + aiScene* pScene, IOSystem* pIOHandler) { std::unique_ptr file( pIOHandler->Open( pFile, "rb")); // Check whether we can read from the file - if( file.get() == NULL) { + if( file.get() == nullptr) { throw DeadlyImportError( "Failed to open ASE file " + pFile + "."); } diff --git a/code/ASELoader.h b/code/ASE/ASELoader.h similarity index 99% rename from code/ASELoader.h rename to code/ASE/ASELoader.h index 33406e3e5..b497aa48b 100644 --- a/code/ASELoader.h +++ b/code/ASE/ASELoader.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2019, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, diff --git a/code/ASEParser.cpp b/code/ASE/ASEParser.cpp similarity index 99% rename from code/ASEParser.cpp rename to code/ASE/ASEParser.cpp index 14b962320..913e7b118 100644 --- a/code/ASEParser.cpp +++ b/code/ASE/ASEParser.cpp @@ -49,15 +49,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER // internal headers -#include "TextureTransform.h" +#include "PostProcessing/TextureTransform.h" #include "ASELoader.h" + #include #include using namespace Assimp; using namespace Assimp::ASE; - // ------------------------------------------------------------------------------------------------ // Begin an ASE parsing function diff --git a/code/ASEParser.h b/code/ASE/ASEParser.h similarity index 99% rename from code/ASEParser.h rename to code/ASE/ASEParser.h index 0cfd5313c..988cbda8d 100644 --- a/code/ASEParser.h +++ b/code/ASE/ASEParser.h @@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include // ASE is quite similar to 3ds. We can reuse some structures -#include "3DSLoader.h" +#include "3DS/3DSLoader.h" namespace Assimp { namespace ASE { diff --git a/code/AssbinExporter.cpp b/code/Assbin/AssbinExporter.cpp similarity index 99% rename from code/AssbinExporter.cpp rename to code/Assbin/AssbinExporter.cpp index 03b0368ce..76c823f82 100644 --- a/code/AssbinExporter.cpp +++ b/code/Assbin/AssbinExporter.cpp @@ -46,12 +46,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER -#include "assbin_chunks.h" +#include "Common/assbin_chunks.h" +#include "PostProcessing/ProcessHelper.h" + #include #include #include #include -#include "ProcessHelper.h" #include #ifdef ASSIMP_BUILD_NO_OWN_ZLIB diff --git a/code/AssbinExporter.h b/code/Assbin/AssbinExporter.h similarity index 100% rename from code/AssbinExporter.h rename to code/Assbin/AssbinExporter.h diff --git a/code/AssbinLoader.cpp b/code/Assbin/AssbinLoader.cpp similarity index 99% rename from code/AssbinLoader.cpp rename to code/Assbin/AssbinLoader.cpp index 249e29863..becc3f8fc 100644 --- a/code/AssbinLoader.cpp +++ b/code/Assbin/AssbinLoader.cpp @@ -50,8 +50,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER // internal headers -#include "AssbinLoader.h" -#include "assbin_chunks.h" +#include "Assbin/AssbinLoader.h" +#include "Common/assbin_chunks.h" #include #include #include diff --git a/code/AssbinLoader.h b/code/Assbin/AssbinLoader.h similarity index 100% rename from code/AssbinLoader.h rename to code/Assbin/AssbinLoader.h diff --git a/code/Assjson/cencode.c b/code/Assjson/cencode.c new file mode 100644 index 000000000..db99e7efa --- /dev/null +++ b/code/Assjson/cencode.c @@ -0,0 +1,109 @@ +/* +cencoder.c - c source to a base64 encoding algorithm implementation + +This is part of the libb64 project, and has been placed in the public domain. +For details, see http://sourceforge.net/projects/libb64 +*/ + +#include "cencode.h" // changed from + +const int CHARS_PER_LINE = 72; + +void base64_init_encodestate(base64_encodestate* state_in) +{ + state_in->step = step_A; + state_in->result = 0; + state_in->stepcount = 0; +} + +char base64_encode_value(char value_in) +{ + static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + if (value_in > 63) return '='; + return encoding[(int)value_in]; +} + +int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in) +{ + const char* plainchar = plaintext_in; + const char* const plaintextend = plaintext_in + length_in; + char* codechar = code_out; + char result; + char fragment; + + result = state_in->result; + + switch (state_in->step) + { + while (1) + { + case step_A: + if (plainchar == plaintextend) + { + state_in->result = result; + state_in->step = step_A; + return codechar - code_out; + } + fragment = *plainchar++; + result = (fragment & 0x0fc) >> 2; + *codechar++ = base64_encode_value(result); + result = (fragment & 0x003) << 4; + case step_B: + if (plainchar == plaintextend) + { + state_in->result = result; + state_in->step = step_B; + return codechar - code_out; + } + fragment = *plainchar++; + result |= (fragment & 0x0f0) >> 4; + *codechar++ = base64_encode_value(result); + result = (fragment & 0x00f) << 2; + case step_C: + if (plainchar == plaintextend) + { + state_in->result = result; + state_in->step = step_C; + return codechar - code_out; + } + fragment = *plainchar++; + result |= (fragment & 0x0c0) >> 6; + *codechar++ = base64_encode_value(result); + result = (fragment & 0x03f) >> 0; + *codechar++ = base64_encode_value(result); + + ++(state_in->stepcount); + if (state_in->stepcount == CHARS_PER_LINE/4) + { + *codechar++ = '\n'; + state_in->stepcount = 0; + } + } + } + /* control should not reach here */ + return codechar - code_out; +} + +int base64_encode_blockend(char* code_out, base64_encodestate* state_in) +{ + char* codechar = code_out; + + switch (state_in->step) + { + case step_B: + *codechar++ = base64_encode_value(state_in->result); + *codechar++ = '='; + *codechar++ = '='; + break; + case step_C: + *codechar++ = base64_encode_value(state_in->result); + *codechar++ = '='; + break; + case step_A: + break; + } + *codechar++ = '\n'; + + return codechar - code_out; +} + diff --git a/code/Assjson/cencode.h b/code/Assjson/cencode.h new file mode 100644 index 000000000..c1e3464af --- /dev/null +++ b/code/Assjson/cencode.h @@ -0,0 +1,31 @@ +/* +cencode.h - c header for a base64 encoding algorithm + +This is part of the libb64 project, and has been placed in the public domain. +For details, see http://sourceforge.net/projects/libb64 +*/ + +#ifndef BASE64_CENCODE_H +#define BASE64_CENCODE_H + +typedef enum +{ + step_A, step_B, step_C +} base64_encodestep; + +typedef struct +{ + base64_encodestep step; + char result; + int stepcount; +} base64_encodestate; + +void base64_init_encodestate(base64_encodestate* state_in); + +char base64_encode_value(char value_in); + +int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in); + +int base64_encode_blockend(char* code_out, base64_encodestate* state_in); + +#endif /* BASE64_CENCODE_H */ diff --git a/code/Assjson/json_exporter.cpp b/code/Assjson/json_exporter.cpp new file mode 100644 index 000000000..2696e779d --- /dev/null +++ b/code/Assjson/json_exporter.cpp @@ -0,0 +1,853 @@ +/* +Assimp2Json +Copyright (c) 2011, Alexander C. Gessler + +Licensed under a 3-clause BSD license. See the LICENSE file for more information. + +*/ + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#define CURRENT_FORMAT_VERSION 100 + +// grab scoped_ptr from assimp to avoid a dependency on boost. +//#include + +#include "mesh_splitter.h" + + +extern "C" { +#include "cencode.h" +} + +namespace { +void Assimp2Json(const char*, Assimp::IOSystem*, const aiScene*, const Assimp::ExportProperties*); +} + +Assimp::Exporter::ExportFormatEntry Assimp2Json_desc = Assimp::Exporter::ExportFormatEntry( + "assimp.json", + "Plain JSON representation of the Assimp scene data structure", + "assimp.json", + Assimp2Json, + 0u); + +namespace { + + + // small utility class to simplify serializing the aiScene to Json +class JSONWriter +{ + +public: + + enum { + Flag_DoNotIndent = 0x1, + Flag_WriteSpecialFloats = 0x2, + }; + +public: + + JSONWriter(Assimp::IOStream& out, unsigned int flags = 0u) + : out(out) + , first() + , flags(flags) + { + // make sure that all formatting happens using the standard, C locale and not the user's current locale + buff.imbue( std::locale("C") ); + } + + ~JSONWriter() + { + Flush(); + } + +public: + + void Flush() { + const std::string s = buff.str(); + out.Write(s.c_str(),s.length(),1); + buff.clear(); + } + + void PushIndent() { + indent += '\t'; + } + + void PopIndent() { + indent.erase(indent.end()-1); + } + + void Key(const std::string& name) { + AddIndentation(); + Delimit(); + buff << '\"'+name+"\": "; + } + + template + void Element(const Literal& name) { + AddIndentation(); + Delimit(); + + LiteralToString(buff, name) << '\n'; + } + + template + void SimpleValue(const Literal& s) { + LiteralToString(buff, s) << '\n'; + } + + + void SimpleValue(const void* buffer, size_t len) { + base64_encodestate s; + base64_init_encodestate(&s); + + char* const out = new char[std::max(len*2, static_cast(16u))]; + const int n = base64_encode_block(reinterpret_cast( buffer ), static_cast( len ),out,&s); + out[n+base64_encode_blockend(out + n,&s)] = '\0'; + + // base64 encoding may add newlines, but JSON strings may not contain 'real' newlines + // (only escaped ones). Remove any newlines in out. + for(char* cur = out; *cur; ++cur) { + if(*cur == '\n') { + *cur = ' '; + } + } + + + buff << '\"' << out << "\"\n"; + delete[] out; + } + + void StartObj(bool is_element = false) { + // if this appears as a plain array element, we need to insert a delimiter and we should also indent it + if(is_element) { + AddIndentation(); + if(!first) { + buff << ','; + } + } + first = true; + buff << "{\n"; + PushIndent(); + } + + void EndObj() { + PopIndent(); + AddIndentation(); + first = false; + buff << "}\n"; + } + + void StartArray(bool is_element = false) { + // if this appears as a plain array element, we need to insert a delimiter and we should also indent it + if(is_element) { + AddIndentation(); + if(!first) { + buff << ','; + } + } + first = true; + buff << "[\n"; + PushIndent(); + } + + void EndArray() { + PopIndent(); + AddIndentation(); + buff << "]\n"; + first = false; + } + + void AddIndentation() { + if(!(flags & Flag_DoNotIndent)) { + buff << indent; + } + } + + void Delimit() { + if(!first) { + buff << ','; + } + else { + buff << ' '; + first = false; + } + } + +private: + + template + std::stringstream& LiteralToString(std::stringstream& stream, const Literal& s) { + stream << s; + return stream; + } + + std::stringstream& LiteralToString(std::stringstream& stream, const aiString& s) { + std::string t; + + // escape backslashes and single quotes, both would render the JSON invalid if left as is + t.reserve(s.length); + for(size_t i = 0; i < s.length; ++i) { + + if (s.data[i] == '\\' || s.data[i] == '\'' || s.data[i] == '\"') { + t.push_back('\\'); + } + + t.push_back(s.data[i]); + } + stream << "\""; + stream << t; + stream << "\""; + return stream; + } + + std::stringstream& LiteralToString(std::stringstream& stream, float f) { + if (!std::numeric_limits::is_iec559) { + // on a non IEEE-754 platform, we make no assumptions about the representation or existence + // of special floating-point numbers. + stream << f; + return stream; + } + + // JSON does not support writing Inf/Nan + // [RFC 4672: "Numeric values that cannot be represented as sequences of digits + // (such as Infinity and NaN) are not permitted."] + // Nevertheless, many parsers will accept the special keywords Infinity, -Infinity and NaN + if (std::numeric_limits::infinity() == fabs(f)) { + if (flags & Flag_WriteSpecialFloats) { + stream << (f < 0 ? "\"-" : "\"") + std::string( "Infinity\"" ); + return stream; + } + // we should print this warning, but we can't - this is called from within a generic assimp exporter, we cannot use cerr + // std::cerr << "warning: cannot represent infinite number literal, substituting 0 instead (use -i flag to enforce Infinity/NaN)" << std::endl; + stream << "0.0"; + return stream; + } + // f!=f is the most reliable test for NaNs that I know of + else if (f != f) { + if (flags & Flag_WriteSpecialFloats) { + stream << "\"NaN\""; + return stream; + } + // we should print this warning, but we can't - this is called from within a generic assimp exporter, we cannot use cerr + // std::cerr << "warning: cannot represent infinite number literal, substituting 0 instead (use -i flag to enforce Infinity/NaN)" << std::endl; + stream << "0.0"; + return stream; + } + + stream << f; + return stream; + } + +private: + Assimp::IOStream& out; + std::string indent, newline; + std::stringstream buff; + bool first; + + unsigned int flags; +}; + + +void Write(JSONWriter& out, const aiVector3D& ai, bool is_elem = true) +{ + out.StartArray(is_elem); + out.Element(ai.x); + out.Element(ai.y); + out.Element(ai.z); + out.EndArray(); +} + +void Write(JSONWriter& out, const aiQuaternion& ai, bool is_elem = true) +{ + out.StartArray(is_elem); + out.Element(ai.w); + out.Element(ai.x); + out.Element(ai.y); + out.Element(ai.z); + out.EndArray(); +} + +void Write(JSONWriter& out, const aiColor3D& ai, bool is_elem = true) +{ + out.StartArray(is_elem); + out.Element(ai.r); + out.Element(ai.g); + out.Element(ai.b); + out.EndArray(); +} + +void Write(JSONWriter& out, const aiMatrix4x4& ai, bool is_elem = true) +{ + out.StartArray(is_elem); + for(unsigned int x = 0; x < 4; ++x) { + for(unsigned int y = 0; y < 4; ++y) { + out.Element(ai[x][y]); + } + } + out.EndArray(); +} + +void Write(JSONWriter& out, const aiBone& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mName); + + out.Key("offsetmatrix"); + Write(out,ai.mOffsetMatrix,false); + + out.Key("weights"); + out.StartArray(); + for(unsigned int i = 0; i < ai.mNumWeights; ++i) { + out.StartArray(true); + out.Element(ai.mWeights[i].mVertexId); + out.Element(ai.mWeights[i].mWeight); + out.EndArray(); + } + out.EndArray(); + out.EndObj(); +} + + +void Write(JSONWriter& out, const aiFace& ai, bool is_elem = true) +{ + out.StartArray(is_elem); + for(unsigned int i = 0; i < ai.mNumIndices; ++i) { + out.Element(ai.mIndices[i]); + } + out.EndArray(); +} + + +void Write(JSONWriter& out, const aiMesh& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mName); + + out.Key("materialindex"); + out.SimpleValue(ai.mMaterialIndex); + + out.Key("primitivetypes"); + out.SimpleValue(ai.mPrimitiveTypes); + + out.Key("vertices"); + out.StartArray(); + for(unsigned int i = 0; i < ai.mNumVertices; ++i) { + out.Element(ai.mVertices[i].x); + out.Element(ai.mVertices[i].y); + out.Element(ai.mVertices[i].z); + } + out.EndArray(); + + if(ai.HasNormals()) { + out.Key("normals"); + out.StartArray(); + for(unsigned int i = 0; i < ai.mNumVertices; ++i) { + out.Element(ai.mNormals[i].x); + out.Element(ai.mNormals[i].y); + out.Element(ai.mNormals[i].z); + } + out.EndArray(); + } + + if(ai.HasTangentsAndBitangents()) { + out.Key("tangents"); + out.StartArray(); + for(unsigned int i = 0; i < ai.mNumVertices; ++i) { + out.Element(ai.mTangents[i].x); + out.Element(ai.mTangents[i].y); + out.Element(ai.mTangents[i].z); + } + out.EndArray(); + + out.Key("bitangents"); + out.StartArray(); + for(unsigned int i = 0; i < ai.mNumVertices; ++i) { + out.Element(ai.mBitangents[i].x); + out.Element(ai.mBitangents[i].y); + out.Element(ai.mBitangents[i].z); + } + out.EndArray(); + } + + if(ai.GetNumUVChannels()) { + out.Key("numuvcomponents"); + out.StartArray(); + for(unsigned int n = 0; n < ai.GetNumUVChannels(); ++n) { + out.Element(ai.mNumUVComponents[n]); + } + out.EndArray(); + + out.Key("texturecoords"); + out.StartArray(); + for(unsigned int n = 0; n < ai.GetNumUVChannels(); ++n) { + + const unsigned int numc = ai.mNumUVComponents[n] ? ai.mNumUVComponents[n] : 2; + + out.StartArray(true); + for(unsigned int i = 0; i < ai.mNumVertices; ++i) { + for(unsigned int c = 0; c < numc; ++c) { + out.Element(ai.mTextureCoords[n][i][c]); + } + } + out.EndArray(); + } + out.EndArray(); + } + + if(ai.GetNumColorChannels()) { + out.Key("colors"); + out.StartArray(); + for(unsigned int n = 0; n < ai.GetNumColorChannels(); ++n) { + + out.StartArray(true); + for(unsigned int i = 0; i < ai.mNumVertices; ++i) { + out.Element(ai.mColors[n][i].r); + out.Element(ai.mColors[n][i].g); + out.Element(ai.mColors[n][i].b); + out.Element(ai.mColors[n][i].a); + } + out.EndArray(); + } + out.EndArray(); + } + + if(ai.mNumBones) { + out.Key("bones"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumBones; ++n) { + Write(out, *ai.mBones[n]); + } + out.EndArray(); + } + + + out.Key("faces"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumFaces; ++n) { + Write(out, ai.mFaces[n]); + } + out.EndArray(); + + out.EndObj(); +} + + +void Write(JSONWriter& out, const aiNode& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mName); + + out.Key("transformation"); + Write(out,ai.mTransformation,false); + + if(ai.mNumMeshes) { + out.Key("meshes"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumMeshes; ++n) { + out.Element(ai.mMeshes[n]); + } + out.EndArray(); + } + + if(ai.mNumChildren) { + out.Key("children"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumChildren; ++n) { + Write(out,*ai.mChildren[n]); + } + out.EndArray(); + } + + out.EndObj(); +} + +void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("properties"); + out.StartArray(); + for(unsigned int i = 0; i < ai.mNumProperties; ++i) { + const aiMaterialProperty* const prop = ai.mProperties[i]; + out.StartObj(true); + out.Key("key"); + out.SimpleValue(prop->mKey); + out.Key("semantic"); + out.SimpleValue(prop->mSemantic); + out.Key("index"); + out.SimpleValue(prop->mIndex); + + out.Key("type"); + out.SimpleValue(prop->mType); + + out.Key("value"); + switch(prop->mType) + { + case aiPTI_Float: + if(prop->mDataLength/sizeof(float) > 1) { + out.StartArray(); + for(unsigned int i = 0; i < prop->mDataLength/sizeof(float); ++i) { + out.Element(reinterpret_cast(prop->mData)[i]); + } + out.EndArray(); + } + else { + out.SimpleValue(*reinterpret_cast(prop->mData)); + } + break; + + case aiPTI_Integer: + if(prop->mDataLength/sizeof(int) > 1) { + out.StartArray(); + for(unsigned int i = 0; i < prop->mDataLength/sizeof(int); ++i) { + out.Element(reinterpret_cast(prop->mData)[i]); + } + out.EndArray(); + } + else { + out.SimpleValue(*reinterpret_cast(prop->mData)); + } + break; + case aiPTI_String: + { + aiString s; + aiGetMaterialString(&ai,prop->mKey.data,prop->mSemantic,prop->mIndex,&s); + out.SimpleValue(s); + } + break; + case aiPTI_Buffer: + { + // binary data is written as series of hex-encoded octets + out.SimpleValue(prop->mData,prop->mDataLength); + } + break; + default: + assert(false); + } + + out.EndObj(); + } + + out.EndArray(); + out.EndObj(); +} + +void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("width"); + out.SimpleValue(ai.mWidth); + + out.Key("height"); + out.SimpleValue(ai.mHeight); + + out.Key("formathint"); + out.SimpleValue(aiString(ai.achFormatHint)); + + out.Key("data"); + if(!ai.mHeight) { + out.SimpleValue(ai.pcData,ai.mWidth); + } + else { + out.StartArray(); + for(unsigned int y = 0; y < ai.mHeight; ++y) { + out.StartArray(true); + for(unsigned int x = 0; x < ai.mWidth; ++x) { + const aiTexel& tx = ai.pcData[y*ai.mWidth+x]; + out.StartArray(true); + out.Element(static_cast(tx.r)); + out.Element(static_cast(tx.g)); + out.Element(static_cast(tx.b)); + out.Element(static_cast(tx.a)); + out.EndArray(); + } + out.EndArray(); + } + out.EndArray(); + } + + out.EndObj(); +} + +void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mName); + + out.Key("type"); + out.SimpleValue(ai.mType); + + if(ai.mType == aiLightSource_SPOT || ai.mType == aiLightSource_UNDEFINED) { + out.Key("angleinnercone"); + out.SimpleValue(ai.mAngleInnerCone); + + out.Key("angleoutercone"); + out.SimpleValue(ai.mAngleOuterCone); + } + + out.Key("attenuationconstant"); + out.SimpleValue(ai.mAttenuationConstant); + + out.Key("attenuationlinear"); + out.SimpleValue(ai.mAttenuationLinear); + + out.Key("attenuationquadratic"); + out.SimpleValue(ai.mAttenuationQuadratic); + + out.Key("diffusecolor"); + Write(out,ai.mColorDiffuse,false); + + out.Key("specularcolor"); + Write(out,ai.mColorSpecular,false); + + out.Key("ambientcolor"); + Write(out,ai.mColorAmbient,false); + + if(ai.mType != aiLightSource_POINT) { + out.Key("direction"); + Write(out,ai.mDirection,false); + + } + + if(ai.mType != aiLightSource_DIRECTIONAL) { + out.Key("position"); + Write(out,ai.mPosition,false); + } + + out.EndObj(); +} + +void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mNodeName); + + out.Key("prestate"); + out.SimpleValue(ai.mPreState); + + out.Key("poststate"); + out.SimpleValue(ai.mPostState); + + if(ai.mNumPositionKeys) { + out.Key("positionkeys"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumPositionKeys; ++n) { + const aiVectorKey& pos = ai.mPositionKeys[n]; + out.StartArray(true); + out.Element(pos.mTime); + Write(out,pos.mValue); + out.EndArray(); + } + out.EndArray(); + } + + if(ai.mNumRotationKeys) { + out.Key("rotationkeys"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumRotationKeys; ++n) { + const aiQuatKey& rot = ai.mRotationKeys[n]; + out.StartArray(true); + out.Element(rot.mTime); + Write(out,rot.mValue); + out.EndArray(); + } + out.EndArray(); + } + + if(ai.mNumScalingKeys) { + out.Key("scalingkeys"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumScalingKeys; ++n) { + const aiVectorKey& scl = ai.mScalingKeys[n]; + out.StartArray(true); + out.Element(scl.mTime); + Write(out,scl.mValue); + out.EndArray(); + } + out.EndArray(); + } + out.EndObj(); +} + +void Write(JSONWriter& out, const aiAnimation& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mName); + + out.Key("tickspersecond"); + out.SimpleValue(ai.mTicksPerSecond); + + out.Key("duration"); + out.SimpleValue(ai.mDuration); + + out.Key("channels"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumChannels; ++n) { + Write(out,*ai.mChannels[n]); + } + out.EndArray(); + out.EndObj(); +} + +void Write(JSONWriter& out, const aiCamera& ai, bool is_elem = true) +{ + out.StartObj(is_elem); + + out.Key("name"); + out.SimpleValue(ai.mName); + + out.Key("aspect"); + out.SimpleValue(ai.mAspect); + + out.Key("clipplanefar"); + out.SimpleValue(ai.mClipPlaneFar); + + out.Key("clipplanenear"); + out.SimpleValue(ai.mClipPlaneNear); + + out.Key("horizontalfov"); + out.SimpleValue(ai.mHorizontalFOV); + + out.Key("up"); + Write(out,ai.mUp,false); + + out.Key("lookat"); + Write(out,ai.mLookAt,false); + + out.EndObj(); +} + +void WriteFormatInfo(JSONWriter& out) +{ + out.StartObj(); + out.Key("format"); + out.SimpleValue("\"assimp2json\""); + out.Key("version"); + out.SimpleValue(CURRENT_FORMAT_VERSION); + out.EndObj(); +} + +void Write(JSONWriter& out, const aiScene& ai) +{ + out.StartObj(); + + out.Key("__metadata__"); + WriteFormatInfo(out); + + out.Key("rootnode"); + Write(out,*ai.mRootNode, false); + + out.Key("flags"); + out.SimpleValue(ai.mFlags); + + if(ai.HasMeshes()) { + out.Key("meshes"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumMeshes; ++n) { + Write(out,*ai.mMeshes[n]); + } + out.EndArray(); + } + + if(ai.HasMaterials()) { + out.Key("materials"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumMaterials; ++n) { + Write(out,*ai.mMaterials[n]); + } + out.EndArray(); + } + + if(ai.HasAnimations()) { + out.Key("animations"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumAnimations; ++n) { + Write(out,*ai.mAnimations[n]); + } + out.EndArray(); + } + + if(ai.HasLights()) { + out.Key("lights"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumLights; ++n) { + Write(out,*ai.mLights[n]); + } + out.EndArray(); + } + + if(ai.HasCameras()) { + out.Key("cameras"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumCameras; ++n) { + Write(out,*ai.mCameras[n]); + } + out.EndArray(); + } + + if(ai.HasTextures()) { + out.Key("textures"); + out.StartArray(); + for(unsigned int n = 0; n < ai.mNumTextures; ++n) { + Write(out,*ai.mTextures[n]); + } + out.EndArray(); + } + out.EndObj(); +} + + +void Assimp2Json(const char* file, Assimp::IOSystem* io, const aiScene* scene, const Assimp::ExportProperties*) +{ + std::unique_ptr str(io->Open(file,"wt")); + if(!str) { + //throw Assimp::DeadlyExportError("could not open output file"); + } + + // get a copy of the scene so we can modify it + aiScene* scenecopy_tmp; + aiCopyScene(scene, &scenecopy_tmp); + + try { + // split meshes so they fit into a 16 bit index buffer + MeshSplitter splitter; + splitter.SetLimit(1 << 16); + splitter.Execute(scenecopy_tmp); + + // XXX Flag_WriteSpecialFloats is turned on by default, right now we don't have a configuration interface for exporters + JSONWriter s(*str,JSONWriter::Flag_WriteSpecialFloats); + Write(s,*scenecopy_tmp); + + } + catch(...) { + aiFreeScene(scenecopy_tmp); + throw; + } + aiFreeScene(scenecopy_tmp); +} + +} // diff --git a/code/Assjson/mesh_splitter.cpp b/code/Assjson/mesh_splitter.cpp new file mode 100644 index 000000000..07ae0bd86 --- /dev/null +++ b/code/Assjson/mesh_splitter.cpp @@ -0,0 +1,327 @@ +/* +Assimp2Json +Copyright (c) 2011, Alexander C. Gessler + +Licensed under a 3-clause BSD license. See the LICENSE file for more information. + +*/ + + +#include "mesh_splitter.h" + +#include + +// ---------------------------------------------------------------------------- +// Note: this is largely based on assimp's SplitLargeMeshes_Vertex process. +// it is refactored and the coding style is slightly improved, though. +// ---------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// Executes the post processing step on the given imported data. +void MeshSplitter :: Execute( aiScene* pScene) +{ + std::vector > source_mesh_map; + + for( unsigned int a = 0; a < pScene->mNumMeshes; a++) { + SplitMesh(a, pScene->mMeshes[a],source_mesh_map); + } + + const unsigned int size = static_cast(source_mesh_map.size()); + if (size != pScene->mNumMeshes) + { + // it seems something has been split. rebuild the mesh list + delete[] pScene->mMeshes; + pScene->mNumMeshes = size; + pScene->mMeshes = new aiMesh*[size](); + + for (unsigned int i = 0; i < size;++i) { + pScene->mMeshes[i] = source_mesh_map[i].first; + } + + // now we need to update all nodes + UpdateNode(pScene->mRootNode,source_mesh_map); + } +} + + +// ------------------------------------------------------------------------------------------------ +void MeshSplitter :: UpdateNode(aiNode* pcNode, const std::vector >& source_mesh_map) +{ + // TODO: should better use std::(multi)set for source_mesh_map. + + // for every index in out list build a new entry + std::vector aiEntries; + aiEntries.reserve(pcNode->mNumMeshes + 1); + for (unsigned int i = 0; i < pcNode->mNumMeshes;++i) { + for (unsigned int a = 0, end = static_cast(source_mesh_map.size()); a < end;++a) { + if (source_mesh_map[a].second == pcNode->mMeshes[i]) { + aiEntries.push_back(a); + } + } + } + + // now build the new list + delete pcNode->mMeshes; + pcNode->mNumMeshes = static_cast(aiEntries.size()); + pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes]; + + for (unsigned int b = 0; b < pcNode->mNumMeshes;++b) { + pcNode->mMeshes[b] = aiEntries[b]; + } + + // recursively update children + for (unsigned int i = 0, end = pcNode->mNumChildren; i < end;++i) { + UpdateNode ( pcNode->mChildren[i], source_mesh_map ); + } + return; +} + +#define WAS_NOT_COPIED 0xffffffff + +typedef std::pair PerVertexWeight; +typedef std::vector VertexWeightTable; + +// ------------------------------------------------------------------------------------------------ +VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh) +{ + if (!pMesh || !pMesh->mNumVertices || !pMesh->mNumBones) { + return NULL; + } + + VertexWeightTable* const avPerVertexWeights = new VertexWeightTable[pMesh->mNumVertices]; + for (unsigned int i = 0; i < pMesh->mNumBones;++i) { + + aiBone* bone = pMesh->mBones[i]; + for (unsigned int a = 0; a < bone->mNumWeights;++a) { + const aiVertexWeight& weight = bone->mWeights[a]; + avPerVertexWeights[weight.mVertexId].push_back( std::make_pair(i,weight.mWeight) ); + } + } + return avPerVertexWeights; +} + +// ------------------------------------------------------------------------------------------------ +void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, + std::vector >& source_mesh_map) +{ + // TODO: should better use std::(multi)set for source_mesh_map. + + if (in_mesh->mNumVertices <= LIMIT) { + source_mesh_map.push_back(std::make_pair(in_mesh,a)); + return; + } + + // build a per-vertex weight list if necessary + VertexWeightTable* avPerVertexWeights = ComputeVertexBoneWeightTable(in_mesh); + + // we need to split this mesh into sub meshes. Estimate submesh size + const unsigned int sub_meshes = (in_mesh->mNumVertices / LIMIT) + 1; + + // create a std::vector to remember which vertices have already + // been copied and to which position (i.e. output index) + std::vector was_copied_to; + was_copied_to.resize(in_mesh->mNumVertices,WAS_NOT_COPIED); + + // Try to find a good estimate for the number of output faces + // per mesh. Add 12.5% as buffer + unsigned int size_estimated = in_mesh->mNumFaces / sub_meshes; + size_estimated += size_estimated / 8; + + // now generate all submeshes + unsigned int base = 0; + while (true) { + const unsigned int out_vertex_index = LIMIT; + + aiMesh* out_mesh = new aiMesh(); + out_mesh->mNumVertices = 0; + out_mesh->mMaterialIndex = in_mesh->mMaterialIndex; + + // the name carries the adjacency information between the meshes + out_mesh->mName = in_mesh->mName; + + typedef std::vector BoneWeightList; + if (in_mesh->HasBones()) { + out_mesh->mBones = new aiBone*[in_mesh->mNumBones](); + } + + // clear the temporary helper array + if (base) { + std::fill(was_copied_to.begin(), was_copied_to.end(), WAS_NOT_COPIED); + } + + std::vector vFaces; + + // reserve enough storage for most cases + if (in_mesh->HasPositions()) { + out_mesh->mVertices = new aiVector3D[out_vertex_index]; + } + + if (in_mesh->HasNormals()) { + out_mesh->mNormals = new aiVector3D[out_vertex_index]; + } + + if (in_mesh->HasTangentsAndBitangents()) { + out_mesh->mTangents = new aiVector3D[out_vertex_index]; + out_mesh->mBitangents = new aiVector3D[out_vertex_index]; + } + + for (unsigned int c = 0; in_mesh->HasVertexColors(c);++c) { + out_mesh->mColors[c] = new aiColor4D[out_vertex_index]; + } + + for (unsigned int c = 0; in_mesh->HasTextureCoords(c);++c) { + out_mesh->mNumUVComponents[c] = in_mesh->mNumUVComponents[c]; + out_mesh->mTextureCoords[c] = new aiVector3D[out_vertex_index]; + } + vFaces.reserve(size_estimated); + + // (we will also need to copy the array of indices) + while (base < in_mesh->mNumFaces) { + const unsigned int iNumIndices = in_mesh->mFaces[base].mNumIndices; + + // doesn't catch degenerates but is quite fast + unsigned int iNeed = 0; + for (unsigned int v = 0; v < iNumIndices;++v) { + unsigned int index = in_mesh->mFaces[base].mIndices[v]; + + // check whether we do already have this vertex + if (WAS_NOT_COPIED == was_copied_to[index]) { + iNeed++; + } + } + if (out_mesh->mNumVertices + iNeed > out_vertex_index) { + // don't use this face + break; + } + + vFaces.push_back(aiFace()); + aiFace& rFace = vFaces.back(); + + // setup face type and number of indices + rFace.mNumIndices = iNumIndices; + rFace.mIndices = new unsigned int[iNumIndices]; + + // need to update the output primitive types + switch (rFace.mNumIndices) + { + case 1: + out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT; + break; + case 2: + out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE; + break; + case 3: + out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; + break; + default: + out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON; + } + + // and copy the contents of the old array, offset them by current base + for (unsigned int v = 0; v < iNumIndices;++v) { + const unsigned int index = in_mesh->mFaces[base].mIndices[v]; + + // check whether we do already have this vertex + if (WAS_NOT_COPIED != was_copied_to[index]) { + rFace.mIndices[v] = was_copied_to[index]; + continue; + } + + // copy positions + out_mesh->mVertices[out_mesh->mNumVertices] = (in_mesh->mVertices[index]); + + // copy normals + if (in_mesh->HasNormals()) { + out_mesh->mNormals[out_mesh->mNumVertices] = (in_mesh->mNormals[index]); + } + + // copy tangents/bi-tangents + if (in_mesh->HasTangentsAndBitangents()) { + out_mesh->mTangents[out_mesh->mNumVertices] = (in_mesh->mTangents[index]); + out_mesh->mBitangents[out_mesh->mNumVertices] = (in_mesh->mBitangents[index]); + } + + // texture coordinates + for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) { + if (in_mesh->HasTextureCoords( c)) { + out_mesh->mTextureCoords[c][out_mesh->mNumVertices] = in_mesh->mTextureCoords[c][index]; + } + } + // vertex colors + for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) { + if (in_mesh->HasVertexColors( c)) { + out_mesh->mColors[c][out_mesh->mNumVertices] = in_mesh->mColors[c][index]; + } + } + // check whether we have bone weights assigned to this vertex + rFace.mIndices[v] = out_mesh->mNumVertices; + if (avPerVertexWeights) { + VertexWeightTable& table = avPerVertexWeights[ out_mesh->mNumVertices ]; + for (VertexWeightTable::const_iterator iter = table.begin(), end = table.end(); iter != end;++iter) { + // allocate the bone weight array if necessary and store it in the mBones field (HACK!) + BoneWeightList* weight_list = reinterpret_cast(out_mesh->mBones[(*iter).first]); + if (!weight_list) { + weight_list = new BoneWeightList(); + out_mesh->mBones[(*iter).first] = reinterpret_cast(weight_list); + } + weight_list->push_back(aiVertexWeight(out_mesh->mNumVertices,(*iter).second)); + } + } + + was_copied_to[index] = out_mesh->mNumVertices; + out_mesh->mNumVertices++; + } + base++; + if(out_mesh->mNumVertices == out_vertex_index) { + // break here. The face is only added if it was complete + break; + } + } + + // check which bones we'll need to create for this submesh + if (in_mesh->HasBones()) { + aiBone** ppCurrent = out_mesh->mBones; + for (unsigned int k = 0; k < in_mesh->mNumBones;++k) { + // check whether the bone exists + BoneWeightList* const weight_list = reinterpret_cast(out_mesh->mBones[k]); + + if (weight_list) { + const aiBone* const bone_in = in_mesh->mBones[k]; + aiBone* const bone_out = new aiBone(); + *ppCurrent++ = bone_out; + bone_out->mName = aiString(bone_in->mName); + bone_out->mOffsetMatrix =bone_in->mOffsetMatrix; + bone_out->mNumWeights = (unsigned int)weight_list->size(); + bone_out->mWeights = new aiVertexWeight[bone_out->mNumWeights]; + + // copy the vertex weights + ::memcpy(bone_out->mWeights, &(*weight_list)[0],bone_out->mNumWeights * sizeof(aiVertexWeight)); + + delete weight_list; + out_mesh->mNumBones++; + } + } + } + + // copy the face list to the mesh + out_mesh->mFaces = new aiFace[vFaces.size()]; + out_mesh->mNumFaces = (unsigned int)vFaces.size(); + + for (unsigned int p = 0; p < out_mesh->mNumFaces;++p) { + out_mesh->mFaces[p] = vFaces[p]; + } + + // add the newly created mesh to the list + source_mesh_map.push_back(std::make_pair(out_mesh,a)); + + if (base == in_mesh->mNumFaces) { + break; + } + } + + // delete the per-vertex weight list again + delete[] avPerVertexWeights; + + // now delete the old mesh data + delete in_mesh; +} diff --git a/code/Assjson/mesh_splitter.h b/code/Assjson/mesh_splitter.h new file mode 100644 index 000000000..326f73b41 --- /dev/null +++ b/code/Assjson/mesh_splitter.h @@ -0,0 +1,61 @@ +/* +Assimp2Json +Copyright (c) 2011, Alexander C. Gessler + +Licensed under a 3-clause BSD license. See the LICENSE file for more information. + +*/ + +#ifndef INCLUDED_MESH_SPLITTER +#define INCLUDED_MESH_SPLITTER + +// ---------------------------------------------------------------------------- +// Note: this is largely based on assimp's SplitLargeMeshes_Vertex process. +// it is refactored and the coding style is slightly improved, though. +// ---------------------------------------------------------------------------- + +#include + +struct aiScene; +struct aiMesh; +struct aiNode; + +// --------------------------------------------------------------------------- +/** Splits meshes of unique vertices into meshes with no more vertices than + * a given, configurable threshold value. + */ +class MeshSplitter +{ + +public: + + void SetLimit(unsigned int l) { + LIMIT = l; + } + + unsigned int GetLimit() const { + return LIMIT; + } + +public: + + // ------------------------------------------------------------------- + /** Executes the post processing step on the given imported data. + * At the moment a process is not supposed to fail. + * @param pScene The imported data to work at. + */ + void Execute( aiScene* pScene); + + +private: + + void UpdateNode(aiNode* pcNode, const std::vector >& source_mesh_map); + void SplitMesh (unsigned int index, aiMesh* mesh, std::vector >& source_mesh_map); + +public: + + unsigned int LIMIT; +}; + +#endif // INCLUDED_MESH_SPLITTER + diff --git a/code/AssxmlExporter.cpp b/code/Assxml/AssxmlExporter.cpp similarity index 99% rename from code/AssxmlExporter.cpp rename to code/Assxml/AssxmlExporter.cpp index 937eebe92..afdecbaf6 100644 --- a/code/AssxmlExporter.cpp +++ b/code/Assxml/AssxmlExporter.cpp @@ -46,13 +46,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER -#include +#include "PostProcessing/ProcessHelper.h" + #include -#include "ProcessHelper.h" #include #include #include +#include + #ifdef ASSIMP_BUILD_NO_OWN_ZLIB # include #else diff --git a/code/AssxmlExporter.h b/code/Assxml/AssxmlExporter.h similarity index 100% rename from code/AssxmlExporter.h rename to code/Assxml/AssxmlExporter.h diff --git a/code/B3DImporter.cpp b/code/B3D/B3DImporter.cpp similarity index 99% rename from code/B3DImporter.cpp rename to code/B3D/B3DImporter.cpp index e48646de9..ba484ca00 100644 --- a/code/B3DImporter.cpp +++ b/code/B3D/B3DImporter.cpp @@ -49,17 +49,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_B3D_IMPORTER // internal headers -#include "B3DImporter.h" -#include "TextureTransform.h" -#include "ConvertToLHProcess.h" +#include "B3D/B3DImporter.h" +#include "PostProcessing/TextureTransform.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include -#include #include #include #include #include #include +#include + using namespace Assimp; using namespace std; diff --git a/code/B3DImporter.h b/code/B3D/B3DImporter.h similarity index 100% rename from code/B3DImporter.h rename to code/B3D/B3DImporter.h diff --git a/code/BVHLoader.cpp b/code/BVH/BVHLoader.cpp similarity index 100% rename from code/BVHLoader.cpp rename to code/BVH/BVHLoader.cpp diff --git a/code/BVHLoader.h b/code/BVH/BVHLoader.h similarity index 100% rename from code/BVHLoader.h rename to code/BVH/BVHLoader.h diff --git a/code/BlenderBMesh.cpp b/code/Blender/BlenderBMesh.cpp similarity index 100% rename from code/BlenderBMesh.cpp rename to code/Blender/BlenderBMesh.cpp diff --git a/code/BlenderBMesh.h b/code/Blender/BlenderBMesh.h similarity index 100% rename from code/BlenderBMesh.h rename to code/Blender/BlenderBMesh.h diff --git a/code/BlenderCustomData.cpp b/code/Blender/BlenderCustomData.cpp similarity index 100% rename from code/BlenderCustomData.cpp rename to code/Blender/BlenderCustomData.cpp diff --git a/code/BlenderCustomData.h b/code/Blender/BlenderCustomData.h similarity index 100% rename from code/BlenderCustomData.h rename to code/Blender/BlenderCustomData.h diff --git a/code/BlenderDNA.cpp b/code/Blender/BlenderDNA.cpp similarity index 100% rename from code/BlenderDNA.cpp rename to code/Blender/BlenderDNA.cpp diff --git a/code/BlenderDNA.h b/code/Blender/BlenderDNA.h similarity index 100% rename from code/BlenderDNA.h rename to code/Blender/BlenderDNA.h diff --git a/code/BlenderDNA.inl b/code/Blender/BlenderDNA.inl similarity index 100% rename from code/BlenderDNA.inl rename to code/Blender/BlenderDNA.inl diff --git a/code/BlenderIntermediate.h b/code/Blender/BlenderIntermediate.h similarity index 100% rename from code/BlenderIntermediate.h rename to code/Blender/BlenderIntermediate.h diff --git a/code/BlenderLoader.cpp b/code/Blender/BlenderLoader.cpp similarity index 100% rename from code/BlenderLoader.cpp rename to code/Blender/BlenderLoader.cpp diff --git a/code/BlenderLoader.h b/code/Blender/BlenderLoader.h similarity index 100% rename from code/BlenderLoader.h rename to code/Blender/BlenderLoader.h diff --git a/code/BlenderModifier.cpp b/code/Blender/BlenderModifier.cpp similarity index 100% rename from code/BlenderModifier.cpp rename to code/Blender/BlenderModifier.cpp diff --git a/code/BlenderModifier.h b/code/Blender/BlenderModifier.h similarity index 100% rename from code/BlenderModifier.h rename to code/Blender/BlenderModifier.h diff --git a/code/BlenderScene.cpp b/code/Blender/BlenderScene.cpp similarity index 100% rename from code/BlenderScene.cpp rename to code/Blender/BlenderScene.cpp diff --git a/code/BlenderScene.h b/code/Blender/BlenderScene.h similarity index 100% rename from code/BlenderScene.h rename to code/Blender/BlenderScene.h diff --git a/code/BlenderSceneGen.h b/code/Blender/BlenderSceneGen.h similarity index 100% rename from code/BlenderSceneGen.h rename to code/Blender/BlenderSceneGen.h diff --git a/code/BlenderTessellator.cpp b/code/Blender/BlenderTessellator.cpp similarity index 100% rename from code/BlenderTessellator.cpp rename to code/Blender/BlenderTessellator.cpp diff --git a/code/BlenderTessellator.h b/code/Blender/BlenderTessellator.h similarity index 98% rename from code/BlenderTessellator.h rename to code/Blender/BlenderTessellator.h index 8675b4e57..518e56c72 100644 --- a/code/BlenderTessellator.h +++ b/code/Blender/BlenderTessellator.h @@ -144,7 +144,11 @@ namespace Assimp #if ASSIMP_BLEND_WITH_POLY_2_TRI -#include "../contrib/poly2tri/poly2tri/poly2tri.h" +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include "../contrib/poly2tri/poly2tri/poly2tri.h" +#endif namespace Assimp { diff --git a/code/C4DImporter.cpp b/code/C4D/C4DImporter.cpp similarity index 100% rename from code/C4DImporter.cpp rename to code/C4D/C4DImporter.cpp diff --git a/code/C4DImporter.h b/code/C4D/C4DImporter.h similarity index 100% rename from code/C4DImporter.h rename to code/C4D/C4DImporter.h diff --git a/code/AssimpCExport.cpp b/code/CApi/AssimpCExport.cpp similarity index 99% rename from code/AssimpCExport.cpp rename to code/CApi/AssimpCExport.cpp index beb3ec3c5..7557edcfc 100644 --- a/code/AssimpCExport.cpp +++ b/code/CApi/AssimpCExport.cpp @@ -49,7 +49,7 @@ Assimp C export interface. See Exporter.cpp for some notes. #include "CInterfaceIOWrapper.h" #include -#include "ScenePrivate.h" +#include "Common/ScenePrivate.h" #include using namespace Assimp; diff --git a/code/CInterfaceIOWrapper.cpp b/code/CApi/CInterfaceIOWrapper.cpp similarity index 100% rename from code/CInterfaceIOWrapper.cpp rename to code/CApi/CInterfaceIOWrapper.cpp diff --git a/code/CInterfaceIOWrapper.h b/code/CApi/CInterfaceIOWrapper.h similarity index 100% rename from code/CInterfaceIOWrapper.h rename to code/CApi/CInterfaceIOWrapper.h diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt index 53da5019e..bdb589bc0 100644 --- a/code/CMakeLists.txt +++ b/code/CMakeLists.txt @@ -2,8 +2,7 @@ # ---------------------------------------------------------------------- # # Copyright (c) 2006-2019, assimp team - - +# # All rights reserved. # # Redistribution and use of this software in source and binary forms, @@ -44,7 +43,7 @@ # 3) Add libassimp using the file lists (eliminates duplication of file names between # source groups and library command) # -cmake_minimum_required( VERSION 2.6 ) +cmake_minimum_required( VERSION 3.0 ) SET( HEADER_PATH ../include/assimp ) if(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM) @@ -61,6 +60,7 @@ SOURCE_GROUP( Compiler FILES ${COMPILER_HEADERS}) SET( PUBLIC_HEADERS ${HEADER_PATH}/anim.h + ${HEADER_PATH}/aabb.h ${HEADER_PATH}/ai_assert.h ${HEADER_PATH}/camera.h ${HEADER_PATH}/color4.h @@ -142,7 +142,7 @@ SET( PUBLIC_HEADERS ) SET( Core_SRCS - Assimp.cpp + Common/Assimp.cpp ) IF(MSVC) @@ -154,52 +154,57 @@ SET( Logging_SRCS ${HEADER_PATH}/LogStream.hpp ${HEADER_PATH}/Logger.hpp ${HEADER_PATH}/NullLogger.hpp - Win32DebugLogStream.h - DefaultLogger.cpp - FileLogStream.h - StdOStreamLogStream.h + Common/Win32DebugLogStream.h + Common/DefaultLogger.cpp + Common/FileLogStream.h + Common/StdOStreamLogStream.h ) SOURCE_GROUP(Logging FILES ${Logging_SRCS}) SET( Common_SRCS - BaseImporter.cpp - BaseProcess.cpp - BaseProcess.h - Importer.h - ScenePrivate.h - PostStepRegistry.cpp - ImporterRegistry.cpp - DefaultProgressHandler.h - DefaultIOStream.cpp - DefaultIOSystem.cpp - CInterfaceIOWrapper.cpp - CInterfaceIOWrapper.h - Importer.cpp - IFF.h - SGSpatialSort.cpp - VertexTriangleAdjacency.cpp - VertexTriangleAdjacency.h - SpatialSort.cpp - SceneCombiner.cpp - ScenePreprocessor.cpp - ScenePreprocessor.h - SkeletonMeshBuilder.cpp - SplitByBoneCountProcess.cpp - SplitByBoneCountProcess.h - StandardShapes.cpp - TargetAnimation.cpp - TargetAnimation.h - RemoveComments.cpp - Subdivision.cpp - scene.cpp - Bitmap.cpp - Version.cpp - CreateAnimMesh.cpp - simd.h - simd.cpp + Common/BaseImporter.cpp + Common/BaseProcess.cpp + Common/BaseProcess.h + Common/Importer.h + Common/ScenePrivate.h + Common/PostStepRegistry.cpp + Common/ImporterRegistry.cpp + Common/DefaultProgressHandler.h + Common/DefaultIOStream.cpp + Common/DefaultIOSystem.cpp + Common/PolyTools.h + Common/Importer.cpp + Common/IFF.h + Common/SGSpatialSort.cpp + Common/VertexTriangleAdjacency.cpp + Common/VertexTriangleAdjacency.h + Common/SpatialSort.cpp + Common/SceneCombiner.cpp + Common/ScenePreprocessor.cpp + Common/ScenePreprocessor.h + Common/SkeletonMeshBuilder.cpp + Common/SplitByBoneCountProcess.cpp + Common/SplitByBoneCountProcess.h + Common/StandardShapes.cpp + Common/TargetAnimation.cpp + Common/TargetAnimation.h + Common/RemoveComments.cpp + Common/Subdivision.cpp + Common/scene.cpp + Common/Bitmap.cpp + Common/Version.cpp + Common/CreateAnimMesh.cpp + Common/simd.h + Common/simd.cpp ) SOURCE_GROUP(Common FILES ${Common_SRCS}) +SET( CApi_SRCS + CApi/CInterfaceIOWrapper.cpp + CApi/CInterfaceIOWrapper.h +) +SOURCE_GROUP(CApi FILES ${CApi_SRCS}) + SET( STEPParser_SRCS Importer/STEPParser/STEPFileReader.h Importer/STEPParser/STEPFileReader.cpp @@ -210,8 +215,8 @@ SOURCE_GROUP(STEPParser FILES ${STEPParser_SRCS}) IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER ) SET( C4D_SRCS - C4DImporter.cpp - C4DImporter.h + C4D/C4DImporter.cpp + C4D/C4DImporter.h ) SOURCE_GROUP( C4D FILES ${C4D_SRCS}) ENDIF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER ) @@ -263,7 +268,7 @@ MACRO(ADD_ASSIMP_EXPORTER name) ELSE () set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER}) ENDIF () - + IF (ASSIMP_EXPORTER_ENABLED) SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}") LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN}) @@ -283,13 +288,13 @@ SET(ASSIMP_EXPORTERS_ENABLED "") # list of enabled exporters SET(ASSIMP_EXPORTERS_DISABLED "") # disabled exporters list (used to print) ADD_ASSIMP_IMPORTER( AMF - AMFImporter.hpp - AMFImporter_Macro.hpp - AMFImporter_Node.hpp - AMFImporter.cpp - AMFImporter_Geometry.cpp - AMFImporter_Material.cpp - AMFImporter_Postprocess.cpp + AMF/AMFImporter.hpp + AMF/AMFImporter_Macro.hpp + AMF/AMFImporter_Node.hpp + AMF/AMFImporter.cpp + AMF/AMFImporter_Geometry.cpp + AMF/AMFImporter_Material.cpp + AMF/AMFImporter_Postprocess.cpp ) ADD_ASSIMP_IMPORTER( JT @@ -298,251 +303,251 @@ ADD_ASSIMP_IMPORTER( JT ) ADD_ASSIMP_IMPORTER( 3DS - 3DSConverter.cpp - 3DSHelper.h - 3DSLoader.cpp - 3DSLoader.h + 3DS/3DSConverter.cpp + 3DS/3DSHelper.h + 3DS/3DSLoader.cpp + 3DS/3DSLoader.h ) ADD_ASSIMP_EXPORTER( 3DS - 3DSExporter.h - 3DSExporter.cpp + 3DS/3DSExporter.h + 3DS/3DSExporter.cpp ) ADD_ASSIMP_IMPORTER( AC - ACLoader.cpp - ACLoader.h + AC/ACLoader.cpp + AC/ACLoader.h ) ADD_ASSIMP_IMPORTER( ASE - ASELoader.cpp - ASELoader.h - ASEParser.cpp - ASEParser.h + ASE/ASELoader.cpp + ASE/ASELoader.h + ASE/ASEParser.cpp + ASE/ASEParser.h ) ADD_ASSIMP_IMPORTER( ASSBIN - AssbinLoader.h - AssbinLoader.cpp + Assbin/AssbinLoader.h + Assbin/AssbinLoader.cpp ) ADD_ASSIMP_EXPORTER( ASSBIN - AssbinExporter.h - AssbinExporter.cpp + Assbin/AssbinExporter.h + Assbin/AssbinExporter.cpp ) -ADD_ASSIMP_IMPORTER( ASSXML - AssxmlExporter.h - AssxmlExporter.cpp +ADD_ASSIMP_EXPORTER( ASSXML + Assxml/AssxmlExporter.h + Assxml/AssxmlExporter.cpp ) ADD_ASSIMP_IMPORTER( B3D - B3DImporter.cpp - B3DImporter.h + B3D/B3DImporter.cpp + B3D/B3DImporter.h ) ADD_ASSIMP_IMPORTER( BVH - BVHLoader.cpp - BVHLoader.h + BVH/BVHLoader.cpp + BVH/BVHLoader.h ) ADD_ASSIMP_IMPORTER( COLLADA - ColladaHelper.h - ColladaLoader.cpp - ColladaLoader.h - ColladaParser.cpp - ColladaParser.h + Collada/ColladaHelper.h + Collada/ColladaLoader.cpp + Collada/ColladaLoader.h + Collada/ColladaParser.cpp + Collada/ColladaParser.h ) ADD_ASSIMP_EXPORTER( COLLADA - ColladaExporter.h - ColladaExporter.cpp + Collada/ColladaExporter.h + Collada/ColladaExporter.cpp ) ADD_ASSIMP_IMPORTER( DXF - DXFLoader.cpp - DXFLoader.h - DXFHelper.h + DXF/DXFLoader.cpp + DXF/DXFLoader.h + DXF/DXFHelper.h ) ADD_ASSIMP_IMPORTER( CSM - CSMLoader.cpp - CSMLoader.h + CSM/CSMLoader.cpp + CSM/CSMLoader.h ) ADD_ASSIMP_IMPORTER( HMP - HMPFileData.h - HMPLoader.cpp - HMPLoader.h - HalfLifeFileData.h + HMP/HMPFileData.h + HMP/HMPLoader.cpp + HMP/HMPLoader.h + HMP/HalfLifeFileData.h ) ADD_ASSIMP_IMPORTER( IRRMESH - IRRMeshLoader.cpp - IRRMeshLoader.h - IRRShared.cpp - IRRShared.h + Irr/IRRMeshLoader.cpp + Irr/IRRMeshLoader.h + Irr/IRRShared.cpp + Irr/IRRShared.h ) ADD_ASSIMP_IMPORTER( IRR - IRRLoader.cpp - IRRLoader.h - IRRShared.cpp - IRRShared.h + Irr/IRRLoader.cpp + Irr/IRRLoader.h + Irr/IRRShared.cpp + Irr/IRRShared.h ) ADD_ASSIMP_IMPORTER( LWO - LWOAnimation.cpp - LWOAnimation.h - LWOBLoader.cpp - LWOFileData.h - LWOLoader.cpp - LWOLoader.h - LWOMaterial.cpp + LWO/LWOAnimation.cpp + LWO/LWOAnimation.h + LWO/LWOBLoader.cpp + LWO/LWOFileData.h + LWO/LWOLoader.cpp + LWO/LWOLoader.h + LWO/LWOMaterial.cpp ) ADD_ASSIMP_IMPORTER( LWS - LWSLoader.cpp - LWSLoader.h + LWS/LWSLoader.cpp + LWS/LWSLoader.h ) ADD_ASSIMP_IMPORTER( MD2 - MD2FileData.h - MD2Loader.cpp - MD2Loader.h - MD2NormalTable.h + MD2/MD2FileData.h + MD2/MD2Loader.cpp + MD2/MD2Loader.h + MD2/MD2NormalTable.h ) ADD_ASSIMP_IMPORTER( MD3 - MD3FileData.h - MD3Loader.cpp - MD3Loader.h + MD3/MD3FileData.h + MD3/MD3Loader.cpp + MD3/MD3Loader.h ) ADD_ASSIMP_IMPORTER( MD5 - MD5Loader.cpp - MD5Loader.h - MD5Parser.cpp - MD5Parser.h + MD5/MD5Loader.cpp + MD5/MD5Loader.h + MD5/MD5Parser.cpp + MD5/MD5Parser.h ) ADD_ASSIMP_IMPORTER( MDC - MDCFileData.h - MDCLoader.cpp - MDCLoader.h - MDCNormalTable.h + MDC/MDCFileData.h + MDC/MDCLoader.cpp + MDC/MDCLoader.h + MDC/MDCNormalTable.h ) ADD_ASSIMP_IMPORTER( MDL - MDLDefaultColorMap.h - MDLFileData.h - MDLLoader.cpp - MDLLoader.h - MDLMaterialLoader.cpp + MDL/MDLDefaultColorMap.h + MDL/MDLFileData.h + MDL/MDLLoader.cpp + MDL/MDLLoader.h + MDL/MDLMaterialLoader.cpp ) SET( MaterialSystem_SRCS - MaterialSystem.cpp - MaterialSystem.h + Material/MaterialSystem.cpp + Material/MaterialSystem.h ) SOURCE_GROUP( MaterialSystem FILES ${MaterialSystem_SRCS}) ADD_ASSIMP_IMPORTER( NFF - NFFLoader.cpp - NFFLoader.h + NFF/NFFLoader.cpp + NFF/NFFLoader.h ) ADD_ASSIMP_IMPORTER( NDO - NDOLoader.cpp - NDOLoader.h + NDO/NDOLoader.cpp + NDO/NDOLoader.h ) ADD_ASSIMP_IMPORTER( OFF - OFFLoader.cpp - OFFLoader.h + OFF/OFFLoader.cpp + OFF/OFFLoader.h ) ADD_ASSIMP_IMPORTER( OBJ - ObjFileData.h - ObjFileImporter.cpp - ObjFileImporter.h - ObjFileMtlImporter.cpp - ObjFileMtlImporter.h - ObjFileParser.cpp - ObjFileParser.h - ObjTools.h + Obj/ObjFileData.h + Obj/ObjFileImporter.cpp + Obj/ObjFileImporter.h + Obj/ObjFileMtlImporter.cpp + Obj/ObjFileMtlImporter.h + Obj/ObjFileParser.cpp + Obj/ObjFileParser.h + Obj/ObjTools.h ) ADD_ASSIMP_EXPORTER( OBJ - ObjExporter.h - ObjExporter.cpp + Obj/ObjExporter.h + Obj/ObjExporter.cpp ) ADD_ASSIMP_IMPORTER( OGRE - OgreImporter.h - OgreStructs.h - OgreParsingUtils.h - OgreBinarySerializer.h - OgreXmlSerializer.h - OgreImporter.cpp - OgreStructs.cpp - OgreBinarySerializer.cpp - OgreXmlSerializer.cpp - OgreMaterial.cpp + Ogre/OgreImporter.h + Ogre/OgreStructs.h + Ogre/OgreParsingUtils.h + Ogre/OgreBinarySerializer.h + Ogre/OgreXmlSerializer.h + Ogre/OgreImporter.cpp + Ogre/OgreStructs.cpp + Ogre/OgreBinarySerializer.cpp + Ogre/OgreXmlSerializer.cpp + Ogre/OgreMaterial.cpp ) ADD_ASSIMP_IMPORTER( OPENGEX - OpenGEXImporter.cpp - OpenGEXImporter.h - OpenGEXStructs.h + OpenGEX/OpenGEXImporter.cpp + OpenGEX/OpenGEXImporter.h + OpenGEX/OpenGEXStructs.h ) ADD_ASSIMP_EXPORTER( OPENGEX - OpenGEXExporter.cpp - OpenGEXExporter.h + OpenGEX/OpenGEXExporter.cpp + OpenGEX/OpenGEXExporter.h ) ADD_ASSIMP_IMPORTER( PLY - PlyLoader.cpp - PlyLoader.h - PlyParser.cpp - PlyParser.h + Ply/PlyLoader.cpp + Ply/PlyLoader.h + Ply/PlyParser.cpp + Ply/PlyParser.h ) ADD_ASSIMP_EXPORTER( PLY - PlyExporter.cpp - PlyExporter.h + Ply/PlyExporter.cpp + Ply/PlyExporter.h ) ADD_ASSIMP_IMPORTER( MS3D - MS3DLoader.cpp - MS3DLoader.h + MS3D/MS3DLoader.cpp + MS3D/MS3DLoader.h ) ADD_ASSIMP_IMPORTER( COB - COBLoader.cpp - COBLoader.h - COBScene.h + COB/COBLoader.cpp + COB/COBLoader.h + COB/COBScene.h ) ADD_ASSIMP_IMPORTER( BLEND - BlenderLoader.cpp - BlenderLoader.h - BlenderDNA.cpp - BlenderDNA.h - BlenderDNA.inl - BlenderScene.cpp - BlenderScene.h - BlenderSceneGen.h - BlenderIntermediate.h - BlenderModifier.h - BlenderModifier.cpp - BlenderBMesh.h - BlenderBMesh.cpp - BlenderTessellator.h - BlenderTessellator.cpp - BlenderCustomData.h - BlenderCustomData.cpp + Blender/BlenderLoader.cpp + Blender/BlenderLoader.h + Blender/BlenderDNA.cpp + Blender/BlenderDNA.h + Blender/BlenderDNA.inl + Blender/BlenderScene.cpp + Blender/BlenderScene.h + Blender/BlenderSceneGen.h + Blender/BlenderIntermediate.h + Blender/BlenderModifier.h + Blender/BlenderModifier.cpp + Blender/BlenderBMesh.h + Blender/BlenderBMesh.cpp + Blender/BlenderTessellator.h + Blender/BlenderTessellator.cpp + Blender/BlenderCustomData.h + Blender/BlenderCustomData.cpp ) ADD_ASSIMP_IMPORTER( IFC @@ -570,106 +575,107 @@ if (ASSIMP_BUILD_IFC_IMPORTER) endif (ASSIMP_BUILD_IFC_IMPORTER) ADD_ASSIMP_IMPORTER( XGL - XGLLoader.cpp - XGLLoader.h + XGL/XGLLoader.cpp + XGL/XGLLoader.h ) ADD_ASSIMP_IMPORTER( FBX - FBXImporter.cpp - FBXCompileConfig.h - FBXImporter.h - FBXParser.cpp - FBXParser.h - FBXTokenizer.cpp - FBXTokenizer.h - FBXImportSettings.h - FBXConverter.h - FBXConverter.cpp - FBXUtil.h - FBXUtil.cpp - FBXDocument.h - FBXDocument.cpp - FBXProperties.h - FBXProperties.cpp - FBXMeshGeometry.h - FBXMeshGeometry.cpp - FBXMaterial.cpp - FBXModel.cpp - FBXAnimation.cpp - FBXNodeAttribute.cpp - FBXDeformer.cpp - FBXBinaryTokenizer.cpp - FBXDocumentUtil.cpp - FBXCommon.h + FBX/FBXImporter.cpp + FBX/FBXCompileConfig.h + FBX/FBXImporter.h + FBX/FBXParser.cpp + FBX/FBXParser.h + FBX/FBXTokenizer.cpp + FBX/FBXTokenizer.h + FBX/FBXImportSettings.h + FBX/FBXConverter.h + FBX/FBXConverter.cpp + FBX/FBXUtil.h + FBX/FBXUtil.cpp + FBX/FBXDocument.h + FBX/FBXDocument.cpp + FBX/FBXProperties.h + FBX/FBXProperties.cpp + FBX/FBXMeshGeometry.h + FBX/FBXMeshGeometry.cpp + FBX/FBXMaterial.cpp + FBX/FBXModel.cpp + FBX/FBXAnimation.cpp + FBX/FBXNodeAttribute.cpp + FBX/FBXDeformer.cpp + FBX/FBXBinaryTokenizer.cpp + FBX/FBXDocumentUtil.cpp + FBX/FBXCommon.h ) ADD_ASSIMP_EXPORTER( FBX - FBXExporter.h - FBXExporter.cpp - FBXExportNode.h - FBXExportNode.cpp - FBXExportProperty.h - FBXExportProperty.cpp + FBX/FBXExporter.h + FBX/FBXExporter.cpp + FBX/FBXExportNode.h + FBX/FBXExportNode.cpp + FBX/FBXExportProperty.h + FBX/FBXExportProperty.cpp ) SET( PostProcessing_SRCS - CalcTangentsProcess.cpp - CalcTangentsProcess.h - ComputeUVMappingProcess.cpp - ComputeUVMappingProcess.h - ConvertToLHProcess.cpp - ConvertToLHProcess.h - EmbedTexturesProcess.cpp - EmbedTexturesProcess.h - FindDegenerates.cpp - FindDegenerates.h - FindInstancesProcess.cpp - FindInstancesProcess.h - FindInvalidDataProcess.cpp - FindInvalidDataProcess.h - FixNormalsStep.cpp - FixNormalsStep.h - DropFaceNormalsProcess.cpp - DropFaceNormalsProcess.h - GenFaceNormalsProcess.cpp - GenFaceNormalsProcess.h - GenVertexNormalsProcess.cpp - GenVertexNormalsProcess.h - PretransformVertices.cpp - PretransformVertices.h - ImproveCacheLocality.cpp - ImproveCacheLocality.h - JoinVerticesProcess.cpp - JoinVerticesProcess.h - LimitBoneWeightsProcess.cpp - LimitBoneWeightsProcess.h - RemoveRedundantMaterials.cpp - RemoveRedundantMaterials.h - RemoveVCProcess.cpp - RemoveVCProcess.h - SortByPTypeProcess.cpp - SortByPTypeProcess.h - SplitLargeMeshes.cpp - SplitLargeMeshes.h - TextureTransform.cpp - TextureTransform.h - TriangulateProcess.cpp - TriangulateProcess.h - ValidateDataStructure.cpp - ValidateDataStructure.h - OptimizeGraph.cpp - OptimizeGraph.h - OptimizeMeshes.cpp - OptimizeMeshes.h - DeboneProcess.cpp - DeboneProcess.h - ProcessHelper.h - ProcessHelper.cpp - PolyTools.h - MakeVerboseFormat.cpp - MakeVerboseFormat.h - ScaleProcess.cpp - ScaleProcess.h + PostProcessing/CalcTangentsProcess.cpp + PostProcessing/CalcTangentsProcess.h + PostProcessing/ComputeUVMappingProcess.cpp + PostProcessing/ComputeUVMappingProcess.h + PostProcessing/ConvertToLHProcess.cpp + PostProcessing/ConvertToLHProcess.h + PostProcessing/EmbedTexturesProcess.cpp + PostProcessing/EmbedTexturesProcess.h + PostProcessing/FindDegenerates.cpp + PostProcessing/FindDegenerates.h + PostProcessing/FindInstancesProcess.cpp + PostProcessing/FindInstancesProcess.h + PostProcessing/FindInvalidDataProcess.cpp + PostProcessing/FindInvalidDataProcess.h + PostProcessing/FixNormalsStep.cpp + PostProcessing/FixNormalsStep.h + PostProcessing/DropFaceNormalsProcess.cpp + PostProcessing/DropFaceNormalsProcess.h + PostProcessing/GenFaceNormalsProcess.cpp + PostProcessing/GenFaceNormalsProcess.h + PostProcessing/GenVertexNormalsProcess.cpp + PostProcessing/GenVertexNormalsProcess.h + PostProcessing/PretransformVertices.cpp + PostProcessing/PretransformVertices.h + PostProcessing/ImproveCacheLocality.cpp + PostProcessing/ImproveCacheLocality.h + PostProcessing/JoinVerticesProcess.cpp + PostProcessing/JoinVerticesProcess.h + PostProcessing/LimitBoneWeightsProcess.cpp + PostProcessing/LimitBoneWeightsProcess.h + PostProcessing/RemoveRedundantMaterials.cpp + PostProcessing/RemoveRedundantMaterials.h + PostProcessing/RemoveVCProcess.cpp + PostProcessing/RemoveVCProcess.h + PostProcessing/SortByPTypeProcess.cpp + PostProcessing/SortByPTypeProcess.h + PostProcessing/SplitLargeMeshes.cpp + PostProcessing/SplitLargeMeshes.h + PostProcessing/TextureTransform.cpp + PostProcessing/TextureTransform.h + PostProcessing/TriangulateProcess.cpp + PostProcessing/TriangulateProcess.h + PostProcessing/ValidateDataStructure.cpp + PostProcessing/ValidateDataStructure.h + PostProcessing/OptimizeGraph.cpp + PostProcessing/OptimizeGraph.h + PostProcessing/OptimizeMeshes.cpp + PostProcessing/OptimizeMeshes.h + PostProcessing/DeboneProcess.cpp + PostProcessing/DeboneProcess.h + PostProcessing/ProcessHelper.h + PostProcessing/ProcessHelper.cpp + PostProcessing/MakeVerboseFormat.cpp + PostProcessing/MakeVerboseFormat.h + PostProcessing/ScaleProcess.cpp + PostProcessing/ScaleProcess.h + PostProcessing/GenBoundingBoxesProcess.cpp + PostProcessing/GenBoundingBoxesProcess.h ) SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS}) @@ -677,136 +683,144 @@ SET( IrrXML_SRCS ${HEADER_PATH}/irrXMLWrapper.h ) SOURCE_GROUP( IrrXML FILES ${IrrXML_SRCS}) ADD_ASSIMP_IMPORTER( Q3D - Q3DLoader.cpp - Q3DLoader.h + Q3D/Q3DLoader.cpp + Q3D/Q3DLoader.h ) ADD_ASSIMP_IMPORTER( Q3BSP - Q3BSPFileData.h - Q3BSPFileParser.h - Q3BSPFileParser.cpp - Q3BSPFileImporter.h - Q3BSPFileImporter.cpp - Q3BSPZipArchive.h - Q3BSPZipArchive.cpp + Q3BSP/Q3BSPFileData.h + Q3BSP/Q3BSPFileParser.h + Q3BSP/Q3BSPFileParser.cpp + Q3BSP/Q3BSPFileImporter.h + Q3BSP/Q3BSPFileImporter.cpp + Q3BSP/Q3BSPZipArchive.h + Q3BSP/Q3BSPZipArchive.cpp ) ADD_ASSIMP_IMPORTER( RAW - RawLoader.cpp - RawLoader.h + Raw/RawLoader.cpp + Raw/RawLoader.h ) ADD_ASSIMP_IMPORTER( SIB - SIBImporter.cpp - SIBImporter.h + SIB/SIBImporter.cpp + SIB/SIBImporter.h ) ADD_ASSIMP_IMPORTER( SMD - SMDLoader.cpp - SMDLoader.h + SMD/SMDLoader.cpp + SMD/SMDLoader.h ) ADD_ASSIMP_IMPORTER( STL - STLLoader.cpp - STLLoader.h + STL/STLLoader.cpp + STL/STLLoader.h ) ADD_ASSIMP_EXPORTER( STL - STLExporter.h - STLExporter.cpp + STL/STLExporter.h + STL/STLExporter.cpp ) ADD_ASSIMP_IMPORTER( TERRAGEN - TerragenLoader.cpp - TerragenLoader.h + Terragen/TerragenLoader.cpp + Terragen/TerragenLoader.h ) ADD_ASSIMP_IMPORTER( 3D - UnrealLoader.cpp - UnrealLoader.h + Unreal/UnrealLoader.cpp + Unreal/UnrealLoader.h ) ADD_ASSIMP_IMPORTER( X - XFileHelper.h - XFileImporter.cpp - XFileImporter.h - XFileParser.cpp - XFileParser.h + X/XFileHelper.h + X/XFileImporter.cpp + X/XFileImporter.h + X/XFileParser.cpp + X/XFileParser.h ) ADD_ASSIMP_EXPORTER( X - XFileExporter.h - XFileExporter.cpp + X/XFileExporter.h + X/XFileExporter.cpp ) ADD_ASSIMP_IMPORTER( X3D - X3DImporter.cpp - X3DImporter.hpp - X3DImporter_Geometry2D.cpp - X3DImporter_Geometry3D.cpp - X3DImporter_Group.cpp - X3DImporter_Light.cpp - X3DImporter_Macro.hpp - X3DImporter_Metadata.cpp - X3DImporter_Networking.cpp - X3DImporter_Node.hpp - X3DImporter_Postprocess.cpp - X3DImporter_Rendering.cpp - X3DImporter_Shape.cpp - X3DImporter_Texturing.cpp - FIReader.hpp - FIReader.cpp - X3DVocabulary.cpp + X3D/X3DImporter.cpp + X3D/X3DImporter.hpp + X3D/X3DImporter_Geometry2D.cpp + X3D/X3DImporter_Geometry3D.cpp + X3D/X3DImporter_Group.cpp + X3D/X3DImporter_Light.cpp + X3D/X3DImporter_Macro.hpp + X3D/X3DImporter_Metadata.cpp + X3D/X3DImporter_Networking.cpp + X3D/X3DImporter_Node.hpp + X3D/X3DImporter_Postprocess.cpp + X3D/X3DImporter_Rendering.cpp + X3D/X3DImporter_Shape.cpp + X3D/X3DImporter_Texturing.cpp + X3D/FIReader.hpp + X3D/FIReader.cpp + X3D/X3DVocabulary.cpp ) ADD_ASSIMP_EXPORTER( X3D - X3DExporter.cpp - X3DExporter.hpp + X3D/X3DExporter.cpp + X3D/X3DExporter.hpp ) ADD_ASSIMP_IMPORTER( GLTF - glTFAsset.h - glTFAsset.inl - glTFAssetWriter.h - glTFAssetWriter.inl - glTFImporter.cpp - glTFImporter.h - glTF2Asset.h - glTF2Asset.inl - glTF2AssetWriter.h - glTF2AssetWriter.inl - glTF2Importer.cpp - glTF2Importer.h + glTF/glTFAsset.h + glTF/glTFAsset.inl + glTF/glTFAssetWriter.h + glTF/glTFAssetWriter.inl + glTF/glTFImporter.cpp + glTF/glTFImporter.h + glTF2/glTF2Asset.h + glTF2/glTF2Asset.inl + glTF2/glTF2AssetWriter.h + glTF2/glTF2AssetWriter.inl + glTF2/glTF2Importer.cpp + glTF2/glTF2Importer.h ) ADD_ASSIMP_EXPORTER( GLTF - glTFExporter.h - glTFExporter.cpp - glTF2Exporter.h - glTF2Exporter.cpp + glTF/glTFExporter.h + glTF/glTFExporter.cpp + glTF2/glTF2Exporter.h + glTF2/glTF2Exporter.cpp ) ADD_ASSIMP_IMPORTER( 3MF - D3MFImporter.h - D3MFImporter.cpp - D3MFOpcPackage.h - D3MFOpcPackage.cpp - 3MFXmlTags.h + 3MF/D3MFImporter.h + 3MF/D3MFImporter.cpp + 3MF/D3MFOpcPackage.h + 3MF/D3MFOpcPackage.cpp + 3MF/3MFXmlTags.h ) ADD_ASSIMP_EXPORTER( 3MF - D3MFExporter.h - D3MFExporter.cpp + 3MF/D3MFExporter.h + 3MF/D3MFExporter.cpp ) ADD_ASSIMP_IMPORTER( MMD - MMDCpp14.h - MMDImporter.cpp - MMDImporter.h - MMDPmdParser.h - MMDPmxParser.h - MMDPmxParser.cpp - MMDVmdParser.h + MMD/MMDCpp14.h + MMD/MMDImporter.cpp + MMD/MMDImporter.h + MMD/MMDPmdParser.h + MMD/MMDPmxParser.h + MMD/MMDPmxParser.cpp + MMD/MMDVmdParser.h +) + +ADD_ASSIMP_EXPORTER( Assjson + Assjson/cencode.c + Assjson/cencode.h + Assjson/json_exporter.cpp + Assjson/mesh_splitter.cpp + Assjson/mesh_splitter.h ) # Workaround for issue #2406 - force problematic large file to be optimized to prevent string table overflow error @@ -822,7 +836,7 @@ if ((CMAKE_COMPILER_IS_MINGW) AND (CMAKE_BUILD_TYPE MATCHES Debug)) endif() ADD_ASSIMP_IMPORTER( STEP - STEPFile.h + Step/STEPFile.h Importer/StepFile/StepFileImporter.h Importer/StepFile/StepFileImporter.cpp Importer/StepFile/StepFileGen1.cpp @@ -832,14 +846,14 @@ ADD_ASSIMP_IMPORTER( STEP ) ADD_ASSIMP_EXPORTER( STEP - StepExporter.h - StepExporter.cpp + Step/StepExporter.h + Step/StepExporter.cpp ) if ((NOT ASSIMP_NO_EXPORT) OR (NOT ASSIMP_EXPORTERS_ENABLED STREQUAL "")) SET( Exporter_SRCS - Exporter.cpp - AssimpCExport.cpp + Common/Exporter.cpp + CApi/AssimpCExport.cpp ${HEADER_PATH}/BlobIOSystem.h ) SOURCE_GROUP( Exporter FILES ${Exporter_SRCS}) @@ -850,116 +864,173 @@ SET( Extra_SRCS ) SOURCE_GROUP( Extra FILES ${Extra_SRCS}) -SET( Clipper_SRCS - ../contrib/clipper/clipper.hpp - ../contrib/clipper/clipper.cpp -) -SOURCE_GROUP( Contrib\\Clipper FILES ${Clipper_SRCS}) +# irrXML +IF(HUNTER_ENABLED) + hunter_add_package(irrXML) + find_package(irrXML CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + # irrXML already included in contrib directory by parent CMakeLists.txt. +ENDIF(HUNTER_ENABLED) -SET( Poly2Tri_SRCS - ../contrib/poly2tri/poly2tri/common/shapes.cc - ../contrib/poly2tri/poly2tri/common/shapes.h - ../contrib/poly2tri/poly2tri/common/utils.h - ../contrib/poly2tri/poly2tri/sweep/advancing_front.h - ../contrib/poly2tri/poly2tri/sweep/advancing_front.cc - ../contrib/poly2tri/poly2tri/sweep/cdt.cc - ../contrib/poly2tri/poly2tri/sweep/cdt.h - ../contrib/poly2tri/poly2tri/sweep/sweep.cc - ../contrib/poly2tri/poly2tri/sweep/sweep.h - ../contrib/poly2tri/poly2tri/sweep/sweep_context.cc - ../contrib/poly2tri/poly2tri/sweep/sweep_context.h -) -SOURCE_GROUP( Contrib\\Poly2Tri FILES ${Poly2Tri_SRCS}) +# utf8 +IF(HUNTER_ENABLED) + hunter_add_package(utf8) + find_package(utf8 CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + # utf8 is header-only, so Assimp doesn't need to do anything. +ENDIF(HUNTER_ENABLED) -SET( unzip_SRCS - ../contrib/unzip/crypt.h - ../contrib/unzip/ioapi.c - ../contrib/unzip/ioapi.h - ../contrib/unzip/unzip.c - ../contrib/unzip/unzip.h -) -SOURCE_GROUP(Contrib\\unzip FILES ${unzip_SRCS}) +# polyclipping +IF(HUNTER_ENABLED) + hunter_add_package(polyclipping) + find_package(polyclipping CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + SET( Clipper_SRCS + ../contrib/clipper/clipper.hpp + ../contrib/clipper/clipper.cpp + ) + SOURCE_GROUP( Contrib\\Clipper FILES ${Clipper_SRCS}) +ENDIF(HUNTER_ENABLED) -SET( ziplib_SRCS - ../contrib/zip/src/miniz.h - ../contrib/zip/src/zip.c - ../contrib/zip/src/zip.h -) +# poly2tri +IF(HUNTER_ENABLED) + hunter_add_package(poly2tri) + find_package(poly2tri CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + SET( Poly2Tri_SRCS + ../contrib/poly2tri/poly2tri/common/shapes.cc + ../contrib/poly2tri/poly2tri/common/shapes.h + ../contrib/poly2tri/poly2tri/common/utils.h + ../contrib/poly2tri/poly2tri/sweep/advancing_front.h + ../contrib/poly2tri/poly2tri/sweep/advancing_front.cc + ../contrib/poly2tri/poly2tri/sweep/cdt.cc + ../contrib/poly2tri/poly2tri/sweep/cdt.h + ../contrib/poly2tri/poly2tri/sweep/sweep.cc + ../contrib/poly2tri/poly2tri/sweep/sweep.h + ../contrib/poly2tri/poly2tri/sweep/sweep_context.cc + ../contrib/poly2tri/poly2tri/sweep/sweep_context.h + ) + SOURCE_GROUP( Contrib\\Poly2Tri FILES ${Poly2Tri_SRCS}) +ENDIF(HUNTER_ENABLED) -# TODO if cmake required version has been updated to >3.12.0, collapse this to the second case only -if(${CMAKE_VERSION} VERSION_LESS "3.12.0") - add_definitions(-DMINIZ_USE_UNALIGNED_LOADS_AND_STORES=0) -else() - add_compile_definitions(MINIZ_USE_UNALIGNED_LOADS_AND_STORES=0) -endif() +# minizip/unzip +IF(HUNTER_ENABLED) + hunter_add_package(minizip) + find_package(minizip CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + SET( unzip_SRCS + ../contrib/unzip/crypt.h + ../contrib/unzip/ioapi.c + ../contrib/unzip/ioapi.h + ../contrib/unzip/unzip.c + ../contrib/unzip/unzip.h + ) + SOURCE_GROUP(Contrib\\unzip FILES ${unzip_SRCS}) +ENDIF(HUNTER_ENABLED) -SOURCE_GROUP( ziplib FILES ${ziplib_SRCS} ) +# zip (https://github.com/kuba--/zip) +IF(HUNTER_ENABLED) + hunter_add_package(zip) + find_package(zip CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + SET( ziplib_SRCS + ../contrib/zip/src/miniz.h + ../contrib/zip/src/zip.c + ../contrib/zip/src/zip.h + ) -SET ( openddl_parser_SRCS - ../contrib/openddlparser/code/OpenDDLParser.cpp - ../contrib/openddlparser/code/DDLNode.cpp - ../contrib/openddlparser/code/OpenDDLCommon.cpp - ../contrib/openddlparser/code/OpenDDLExport.cpp - ../contrib/openddlparser/code/Value.cpp - ../contrib/openddlparser/code/OpenDDLStream.cpp - ../contrib/openddlparser/include/openddlparser/OpenDDLParser.h - ../contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h - ../contrib/openddlparser/include/openddlparser/OpenDDLCommon.h - ../contrib/openddlparser/include/openddlparser/OpenDDLExport.h - ../contrib/openddlparser/include/openddlparser/OpenDDLStream.h - ../contrib/openddlparser/include/openddlparser/DDLNode.h - ../contrib/openddlparser/include/openddlparser/Value.h -) -SOURCE_GROUP( Contrib\\openddl_parser FILES ${openddl_parser_SRCS}) + # TODO if cmake required version has been updated to >3.12.0, collapse this to the second case only + if(${CMAKE_VERSION} VERSION_LESS "3.12.0") + add_definitions(-DMINIZ_USE_UNALIGNED_LOADS_AND_STORES=0) + else() + add_compile_definitions(MINIZ_USE_UNALIGNED_LOADS_AND_STORES=0) + endif() -SET ( open3dgc_SRCS - ../contrib/Open3DGC/o3dgcAdjacencyInfo.h - ../contrib/Open3DGC/o3dgcArithmeticCodec.cpp - ../contrib/Open3DGC/o3dgcArithmeticCodec.h - ../contrib/Open3DGC/o3dgcBinaryStream.h - ../contrib/Open3DGC/o3dgcCommon.h - ../contrib/Open3DGC/o3dgcDVEncodeParams.h - ../contrib/Open3DGC/o3dgcDynamicVectorDecoder.cpp - ../contrib/Open3DGC/o3dgcDynamicVectorDecoder.h - ../contrib/Open3DGC/o3dgcDynamicVectorEncoder.cpp - ../contrib/Open3DGC/o3dgcDynamicVectorEncoder.h - ../contrib/Open3DGC/o3dgcDynamicVector.h - ../contrib/Open3DGC/o3dgcFIFO.h - ../contrib/Open3DGC/o3dgcIndexedFaceSet.h - ../contrib/Open3DGC/o3dgcIndexedFaceSet.inl - ../contrib/Open3DGC/o3dgcSC3DMCDecoder.h - ../contrib/Open3DGC/o3dgcSC3DMCDecoder.inl - ../contrib/Open3DGC/o3dgcSC3DMCEncodeParams.h - ../contrib/Open3DGC/o3dgcSC3DMCEncoder.h - ../contrib/Open3DGC/o3dgcSC3DMCEncoder.inl - ../contrib/Open3DGC/o3dgcTimer.h - ../contrib/Open3DGC/o3dgcTools.cpp - ../contrib/Open3DGC/o3dgcTriangleFans.cpp - ../contrib/Open3DGC/o3dgcTriangleFans.h - ../contrib/Open3DGC/o3dgcTriangleListDecoder.h - ../contrib/Open3DGC/o3dgcTriangleListDecoder.inl - ../contrib/Open3DGC/o3dgcTriangleListEncoder.h - ../contrib/Open3DGC/o3dgcTriangleListEncoder.inl - ../contrib/Open3DGC/o3dgcVector.h - ../contrib/Open3DGC/o3dgcVector.inl -) -SOURCE_GROUP( Contrib\\open3dgc FILES ${open3dgc_SRCS}) + SOURCE_GROUP( ziplib FILES ${ziplib_SRCS} ) +ENDIF(HUNTER_ENABLED) + +# openddlparser +IF(HUNTER_ENABLED) + hunter_add_package(openddlparser) + find_package(openddlparser CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + SET ( openddl_parser_SRCS + ../contrib/openddlparser/code/OpenDDLParser.cpp + ../contrib/openddlparser/code/DDLNode.cpp + ../contrib/openddlparser/code/OpenDDLCommon.cpp + ../contrib/openddlparser/code/OpenDDLExport.cpp + ../contrib/openddlparser/code/Value.cpp + ../contrib/openddlparser/code/OpenDDLStream.cpp + ../contrib/openddlparser/include/openddlparser/OpenDDLParser.h + ../contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h + ../contrib/openddlparser/include/openddlparser/OpenDDLCommon.h + ../contrib/openddlparser/include/openddlparser/OpenDDLExport.h + ../contrib/openddlparser/include/openddlparser/OpenDDLStream.h + ../contrib/openddlparser/include/openddlparser/DDLNode.h + ../contrib/openddlparser/include/openddlparser/Value.h + ) + SOURCE_GROUP( Contrib\\openddl_parser FILES ${openddl_parser_SRCS}) +ENDIF(HUNTER_ENABLED) + +# Open3DGC +IF(HUNTER_ENABLED) + # Nothing to do, not available in Hunter yet. +ELSE(HUNTER_ENABLED) + SET ( open3dgc_SRCS + ../contrib/Open3DGC/o3dgcAdjacencyInfo.h + ../contrib/Open3DGC/o3dgcArithmeticCodec.cpp + ../contrib/Open3DGC/o3dgcArithmeticCodec.h + ../contrib/Open3DGC/o3dgcBinaryStream.h + ../contrib/Open3DGC/o3dgcCommon.h + ../contrib/Open3DGC/o3dgcDVEncodeParams.h + ../contrib/Open3DGC/o3dgcDynamicVectorDecoder.cpp + ../contrib/Open3DGC/o3dgcDynamicVectorDecoder.h + ../contrib/Open3DGC/o3dgcDynamicVectorEncoder.cpp + ../contrib/Open3DGC/o3dgcDynamicVectorEncoder.h + ../contrib/Open3DGC/o3dgcDynamicVector.h + ../contrib/Open3DGC/o3dgcFIFO.h + ../contrib/Open3DGC/o3dgcIndexedFaceSet.h + ../contrib/Open3DGC/o3dgcIndexedFaceSet.inl + ../contrib/Open3DGC/o3dgcSC3DMCDecoder.h + ../contrib/Open3DGC/o3dgcSC3DMCDecoder.inl + ../contrib/Open3DGC/o3dgcSC3DMCEncodeParams.h + ../contrib/Open3DGC/o3dgcSC3DMCEncoder.h + ../contrib/Open3DGC/o3dgcSC3DMCEncoder.inl + ../contrib/Open3DGC/o3dgcTimer.h + ../contrib/Open3DGC/o3dgcTools.cpp + ../contrib/Open3DGC/o3dgcTriangleFans.cpp + ../contrib/Open3DGC/o3dgcTriangleFans.h + ../contrib/Open3DGC/o3dgcTriangleListDecoder.h + ../contrib/Open3DGC/o3dgcTriangleListDecoder.inl + ../contrib/Open3DGC/o3dgcTriangleListEncoder.h + ../contrib/Open3DGC/o3dgcTriangleListEncoder.inl + ../contrib/Open3DGC/o3dgcVector.h + ../contrib/Open3DGC/o3dgcVector.inl + ) + SOURCE_GROUP( Contrib\\open3dgc FILES ${open3dgc_SRCS}) +ENDIF(HUNTER_ENABLED) # Check dependencies for glTF importer with Open3DGC-compression. # RT-extensions is used in "contrib/Open3DGC/o3dgcTimer.h" for collecting statistics. Pointed file # has implementation for different platforms: WIN32, __MACH__ and other ("else" block). FIND_PACKAGE(RT QUIET) -IF (RT_FOUND OR MSVC) +IF (NOT HUNTER_ENABLED AND (RT_FOUND OR MSVC)) SET( ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC 1 ) ADD_DEFINITIONS( -DASSIMP_IMPORTER_GLTF_USE_OPEN3DGC=1 ) ELSE () SET (open3dgc_SRCS "") - MESSAGE (INFO " RT-extension not found. glTF import/export will be built without Open3DGC-compression.") + MESSAGE (INFO " Hunter enabled or RT-extension not found. glTF import/export will be built without Open3DGC-compression.") #!TODO: off course is better to remove statistics timers from o3dgc codec. Or propose to choose what to use. ENDIF () -INCLUDE_DIRECTORIES( "../contrib/rapidjson/include" ) -INCLUDE_DIRECTORIES( "../contrib" ) +# RapidJSON +IF(HUNTER_ENABLED) + hunter_add_package(RapidJSON) + find_package(RapidJSON CONFIG REQUIRED) +ELSE(HUNTER_ENABLED) + INCLUDE_DIRECTORIES( "../contrib/rapidjson/include" ) + INCLUDE_DIRECTORIES( "../contrib" ) +ENDIF(HUNTER_ENABLED) # VC2010 fixes if(MSVC10) @@ -976,12 +1047,14 @@ if ( MSVC ) ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS ) endif ( MSVC ) -if (UNZIP_FOUND) - SET (unzip_compile_SRCS "") -else (UNZIP_FOUND) - SET (unzip_compile_SRCS ${unzip_SRCS}) - INCLUDE_DIRECTORIES( "../contrib/unzip/" ) -endif (UNZIP_FOUND) +IF(NOT HUNTER_ENABLED) + if (UNZIP_FOUND) + SET (unzip_compile_SRCS "") + else (UNZIP_FOUND) + SET (unzip_compile_SRCS ${unzip_SRCS}) + INCLUDE_DIRECTORIES( "../contrib/unzip/" ) + endif (UNZIP_FOUND) +ENDIF(NOT HUNTER_ENABLED) MESSAGE(STATUS "Enabled importer formats:${ASSIMP_IMPORTERS_ENABLED}") MESSAGE(STATUS "Disabled importer formats:${ASSIMP_IMPORTERS_DISABLED}") @@ -992,6 +1065,7 @@ MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}") SET( assimp_src # Assimp Files ${Core_SRCS} + ${CApi_SRCS} ${Common_SRCS} ${Logging_SRCS} ${Exporter_SRCS} @@ -1019,10 +1093,12 @@ SET( assimp_src ) ADD_DEFINITIONS( -DOPENDDLPARSER_BUILD ) -INCLUDE_DIRECTORIES( - ${IRRXML_INCLUDE_DIR} - ../contrib/openddlparser/include -) +IF(NOT HUNTER_ENABLED) + INCLUDE_DIRECTORIES( + ${IRRXML_INCLUDE_DIR} + ../contrib/openddlparser/include + ) +ENDIF(NOT HUNTER_ENABLED) IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER) SET( assimp_src ${assimp_src} ${C4D_SRCS}) @@ -1035,10 +1111,25 @@ ADD_LIBRARY(assimp::assimp ALIAS assimp) TARGET_INCLUDE_DIRECTORIES ( assimp PUBLIC $ $ - $ + $ ) -TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} ${IRRXML_LIBRARY} ) +IF(HUNTER_ENABLED) + TARGET_LINK_LIBRARIES(assimp + PUBLIC + polyclipping::polyclipping + irrXML::irrXML + openddlparser::openddl_parser + poly2tri::poly2tri + minizip::minizip + ZLIB::zlib + RapidJSON::rapidjson + utf8::utf8 + zip::zip + ) +ELSE(HUNTER_ENABLED) + TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} ${IRRXML_LIBRARY} ) +ENDIF(HUNTER_ENABLED) if(ASSIMP_ANDROID_JNIIOSYSTEM) set(ASSIMP_ANDROID_JNIIOSYSTEM_PATH port/AndroidJNI) @@ -1058,31 +1149,36 @@ if( MSVC ) if(MSVC_TOOLSET_VERSION) set(MSVC_PREFIX "vc${MSVC_TOOLSET_VERSION}") else() - if( MSVC70 OR MSVC71 ) - set(MSVC_PREFIX "vc70") - elseif( MSVC80 ) - set(MSVC_PREFIX "vc80") - elseif( MSVC90 ) - set(MSVC_PREFIX "vc90") - elseif( MSVC10 ) - set(MSVC_PREFIX "vc100") - elseif( MSVC11 ) - set(MSVC_PREFIX "vc110") - elseif( MSVC12 ) - set(MSVC_PREFIX "vc120") - elseif( MSVC14 ) - set(MSVC_PREFIX "vc140") - elseif( MSVC15 ) - set(MSVC_PREFIX "vc141") - else() - set(MSVC_PREFIX "vc150") - endif() + if( MSVC70 OR MSVC71 ) + set(MSVC_PREFIX "vc70") + elseif( MSVC80 ) + set(MSVC_PREFIX "vc80") + elseif( MSVC90 ) + set(MSVC_PREFIX "vc90") + elseif( MSVC10 ) + set(MSVC_PREFIX "vc100") + elseif( MSVC11 ) + set(MSVC_PREFIX "vc110") + elseif( MSVC12 ) + set(MSVC_PREFIX "vc120") + elseif( MSVC_VERSION LESS 1910) + set(MSVC_PREFIX "vc140") + elseif( MSVC_VERSION LESS 1920) + set(MSVC_PREFIX "vc141") + elseif( MSVC_VERSION LESS 1930) + set(MSVC_PREFIX "vc142") + else() + MESSAGE(WARNING "unknown msvc version ${MSVC_VERSION}") + set(MSVC_PREFIX "vc150") + endif() endif() set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library") endif() if (${CMAKE_SYSTEM_NAME} MATCHES "WindowsStore") - set(WindowsStore TRUE) + target_compile_definitions(assimp PUBLIC WindowsStore) + TARGET_LINK_LIBRARIES(assimp advapi32) + #set(WindowsStore TRUE) endif() SET_TARGET_PROPERTIES( assimp PROPERTIES VERSION ${ASSIMP_VERSION} @@ -1115,24 +1211,37 @@ ENDIF(APPLE) # Build against external unzip, or add ../contrib/unzip so # assimp can #include "unzip.h" -if (UNZIP_FOUND) - INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS}) - TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES}) -else (UNZIP_FOUND) - INCLUDE_DIRECTORIES("../") -endif (UNZIP_FOUND) +IF(NOT HUNTER_ENABLED) + if (UNZIP_FOUND) + INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS}) + TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES}) + else (UNZIP_FOUND) + INCLUDE_DIRECTORIES("../") + endif (UNZIP_FOUND) +ENDIF(NOT HUNTER_ENABLED) # Add RT-extension library for glTF importer with Open3DGC-compression. IF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC) TARGET_LINK_LIBRARIES(assimp ${RT_LIBRARY}) ENDIF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC) +IF(HUNTER_ENABLED) + INSTALL( TARGETS assimp + EXPORT "${TARGETS_EXPORT_NAME}" + LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR} + ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR} + RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR} + FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR} + COMPONENT ${LIBASSIMP_COMPONENT} + INCLUDES DESTINATION "include") +ELSE(HUNTER_ENABLED) INSTALL( TARGETS assimp - LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR} - ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR} - RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR} - FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR} - COMPONENT ${LIBASSIMP_COMPONENT}) + LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR} + ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR} + RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR} + FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR} + COMPONENT ${LIBASSIMP_COMPONENT}) +ENDIF(HUNTER_ENABLED) INSTALL( FILES ${PUBLIC_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp COMPONENT assimp-dev) INSTALL( FILES ${COMPILER_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp/Compiler COMPONENT assimp-dev) diff --git a/code/COBLoader.cpp b/code/COB/COBLoader.cpp similarity index 99% rename from code/COBLoader.cpp rename to code/COB/COBLoader.cpp index b7e0f9728..b9eb5b7ea 100644 --- a/code/COBLoader.cpp +++ b/code/COB/COBLoader.cpp @@ -45,20 +45,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_COB_IMPORTER -#include "COBLoader.h" -#include "COBScene.h" -#include "ConvertToLHProcess.h" +#include "COB/COBLoader.h" +#include "COB/COBScene.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include #include #include #include #include -#include #include #include #include #include +#include + using namespace Assimp; using namespace Assimp::COB; using namespace Assimp::Formatter; diff --git a/code/COBLoader.h b/code/COB/COBLoader.h similarity index 100% rename from code/COBLoader.h rename to code/COB/COBLoader.h diff --git a/code/COBScene.h b/code/COB/COBScene.h similarity index 100% rename from code/COBScene.h rename to code/COB/COBScene.h diff --git a/code/CSMLoader.cpp b/code/CSM/CSMLoader.cpp similarity index 100% rename from code/CSMLoader.cpp rename to code/CSM/CSMLoader.cpp diff --git a/code/CSMLoader.h b/code/CSM/CSMLoader.h similarity index 100% rename from code/CSMLoader.h rename to code/CSM/CSMLoader.h diff --git a/code/ColladaExporter.cpp b/code/Collada/ColladaExporter.cpp similarity index 99% rename from code/ColladaExporter.cpp rename to code/Collada/ColladaExporter.cpp index 7c21dde43..cace8460e 100644 --- a/code/ColladaExporter.cpp +++ b/code/Collada/ColladaExporter.cpp @@ -99,7 +99,7 @@ ColladaExporter::ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, co , mFile(file) { // make sure that all formatting happens using the standard, C locale and not the user's current locale mOutput.imbue( std::locale("C") ); - mOutput.precision(16); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); mScene = pScene; mSceneOwned = false; @@ -1671,4 +1671,4 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode) } #endif -#endif +#endif \ No newline at end of file diff --git a/code/ColladaExporter.h b/code/Collada/ColladaExporter.h similarity index 99% rename from code/ColladaExporter.h rename to code/Collada/ColladaExporter.h index 8244b61aa..0b4fa59a3 100644 --- a/code/ColladaExporter.h +++ b/code/Collada/ColladaExporter.h @@ -150,7 +150,6 @@ public: /// Stringstream to write all output into std::stringstream mOutput; -protected: /// The IOSystem for output IOSystem* mIOSystem; @@ -204,7 +203,7 @@ protected: std::map textures; -protected: +public: /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions /// Reads a single surface entry from the given material keys void ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex); diff --git a/code/ColladaHelper.h b/code/Collada/ColladaHelper.h similarity index 100% rename from code/ColladaHelper.h rename to code/Collada/ColladaHelper.h diff --git a/code/ColladaLoader.cpp b/code/Collada/ColladaLoader.cpp similarity index 100% rename from code/ColladaLoader.cpp rename to code/Collada/ColladaLoader.cpp diff --git a/code/ColladaLoader.h b/code/Collada/ColladaLoader.h similarity index 100% rename from code/ColladaLoader.h rename to code/Collada/ColladaLoader.h diff --git a/code/ColladaParser.cpp b/code/Collada/ColladaParser.cpp similarity index 99% rename from code/ColladaParser.cpp rename to code/Collada/ColladaParser.cpp index 2106bf01c..860ae2ae9 100644 --- a/code/ColladaParser.cpp +++ b/code/Collada/ColladaParser.cpp @@ -323,10 +323,8 @@ void ColladaParser::ReadMetaDataItem(StringMetaData &metadata) aiString aistr; aistr.Set(value_char); metadata.emplace(camel_key_str, aistr); - TestClosing(key_str.c_str()); } - else - SkipElement(); + TestClosing(key_str.c_str()); } else SkipElement(); diff --git a/code/ColladaParser.h b/code/Collada/ColladaParser.h similarity index 100% rename from code/ColladaParser.h rename to code/Collada/ColladaParser.h diff --git a/code/Assimp.cpp b/code/Common/Assimp.cpp similarity index 99% rename from code/Assimp.cpp rename to code/Common/Assimp.cpp index 41e1a4800..178b2c01d 100644 --- a/code/Assimp.cpp +++ b/code/Common/Assimp.cpp @@ -54,7 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "CInterfaceIOWrapper.h" +#include "CApi/CInterfaceIOWrapper.h" #include "Importer.h" #include "ScenePrivate.h" diff --git a/code/BaseImporter.cpp b/code/Common/BaseImporter.cpp similarity index 99% rename from code/BaseImporter.cpp rename to code/Common/BaseImporter.cpp index 4803c6d6f..0a5694aa0 100644 --- a/code/BaseImporter.cpp +++ b/code/Common/BaseImporter.cpp @@ -320,7 +320,11 @@ std::string BaseImporter::GetExtension( const std::string& file ) { return false; } -#include "../contrib/utf8cpp/source/utf8.h" +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include "../contrib/utf8cpp/source/utf8.h" +#endif // ------------------------------------------------------------------------------------------------ // Convert to UTF8 data diff --git a/code/BaseProcess.cpp b/code/Common/BaseProcess.cpp similarity index 98% rename from code/BaseProcess.cpp rename to code/Common/BaseProcess.cpp index 18872c369..e247be418 100644 --- a/code/BaseProcess.cpp +++ b/code/Common/BaseProcess.cpp @@ -89,7 +89,7 @@ void BaseProcess::ExecuteOnScene( Importer* pImp) // and kill the partially imported data delete pImp->Pimpl()->mScene; - pImp->Pimpl()->mScene = NULL; + pImp->Pimpl()->mScene = nullptr; } } diff --git a/code/BaseProcess.h b/code/Common/BaseProcess.h similarity index 100% rename from code/BaseProcess.h rename to code/Common/BaseProcess.h diff --git a/code/Bitmap.cpp b/code/Common/Bitmap.cpp similarity index 100% rename from code/Bitmap.cpp rename to code/Common/Bitmap.cpp diff --git a/code/CreateAnimMesh.cpp b/code/Common/CreateAnimMesh.cpp similarity index 100% rename from code/CreateAnimMesh.cpp rename to code/Common/CreateAnimMesh.cpp diff --git a/code/DefaultIOStream.cpp b/code/Common/DefaultIOStream.cpp similarity index 100% rename from code/DefaultIOStream.cpp rename to code/Common/DefaultIOStream.cpp diff --git a/code/DefaultIOSystem.cpp b/code/Common/DefaultIOSystem.cpp similarity index 100% rename from code/DefaultIOSystem.cpp rename to code/Common/DefaultIOSystem.cpp diff --git a/code/DefaultLogger.cpp b/code/Common/DefaultLogger.cpp similarity index 100% rename from code/DefaultLogger.cpp rename to code/Common/DefaultLogger.cpp diff --git a/code/DefaultProgressHandler.h b/code/Common/DefaultProgressHandler.h similarity index 100% rename from code/DefaultProgressHandler.h rename to code/Common/DefaultProgressHandler.h diff --git a/code/Exporter.cpp b/code/Common/Exporter.cpp similarity index 98% rename from code/Exporter.cpp rename to code/Common/Exporter.cpp index 4ecb07081..b1caa4f96 100644 --- a/code/Exporter.cpp +++ b/code/Common/Exporter.cpp @@ -61,15 +61,16 @@ Here we implement only the C++ interface (Assimp::Exporter). #include #include #include - -#include "DefaultProgressHandler.h" -#include "BaseProcess.h" -#include "JoinVerticesProcess.h" -#include "MakeVerboseFormat.h" -#include "ConvertToLHProcess.h" -#include "PretransformVertices.h" #include -#include "ScenePrivate.h" + +#include "Common/DefaultProgressHandler.h" +#include "Common/BaseProcess.h" +#include "Common/ScenePrivate.h" +#include "PostProcessing/CalcTangentsProcess.h" +#include "PostProcessing/MakeVerboseFormat.h" +#include "PostProcessing/JoinVerticesProcess.h" +#include "PostProcessing/ConvertToLHProcess.h" +#include "PostProcessing/PretransformVertices.h" #include diff --git a/code/FileLogStream.h b/code/Common/FileLogStream.h similarity index 100% rename from code/FileLogStream.h rename to code/Common/FileLogStream.h diff --git a/code/FileSystemFilter.h b/code/Common/FileSystemFilter.h similarity index 100% rename from code/FileSystemFilter.h rename to code/Common/FileSystemFilter.h diff --git a/code/IFF.h b/code/Common/IFF.h similarity index 100% rename from code/IFF.h rename to code/Common/IFF.h diff --git a/code/Importer.cpp b/code/Common/Importer.cpp similarity index 98% rename from code/Importer.cpp rename to code/Common/Importer.cpp index 65b16471c..91b50859a 100644 --- a/code/Importer.cpp +++ b/code/Common/Importer.cpp @@ -64,15 +64,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // ------------------------------------------------------------------------------------------------ // Internal headers // ------------------------------------------------------------------------------------------------ -#include "Importer.h" -#include -#include "BaseProcess.h" +#include "Common/Importer.h" +#include "Common/BaseProcess.h" +#include "Common/DefaultProgressHandler.h" +#include "PostProcessing/ProcessHelper.h" +#include "Common/ScenePreprocessor.h" +#include "Common/ScenePrivate.h" -#include "DefaultProgressHandler.h" +#include #include -#include "ProcessHelper.h" -#include "ScenePreprocessor.h" -#include "ScenePrivate.h" #include #include #include @@ -86,7 +86,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS -# include "ValidateDataStructure.h" +# include "PostProcessing/ValidateDataStructure.h" #endif using namespace Assimp::Profiling; @@ -590,10 +590,12 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) // Find an worker class which can handle the file BaseImporter* imp = NULL; + SetPropertyInteger("importerIndex", -1); for( unsigned int a = 0; a < pimpl->mImporter.size(); a++) { if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, false)) { imp = pimpl->mImporter[a]; + SetPropertyInteger("importerIndex", a); break; } } @@ -606,6 +608,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) for( unsigned int a = 0; a < pimpl->mImporter.size(); a++) { if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) { imp = pimpl->mImporter[a]; + SetPropertyInteger("importerIndex", a); break; } } diff --git a/code/Importer.h b/code/Common/Importer.h similarity index 100% rename from code/Importer.h rename to code/Common/Importer.h diff --git a/code/ImporterRegistry.cpp b/code/Common/ImporterRegistry.cpp similarity index 86% rename from code/ImporterRegistry.cpp rename to code/Common/ImporterRegistry.cpp index 69a50bf27..b99f145ab 100644 --- a/code/ImporterRegistry.cpp +++ b/code/Common/ImporterRegistry.cpp @@ -56,146 +56,146 @@ corresponding preprocessor flag to selectively disable formats. // (include_new_importers_here) // ------------------------------------------------------------------------------------------------ #ifndef ASSIMP_BUILD_NO_X_IMPORTER -# include "XFileImporter.h" +# include "X/XFileImporter.h" #endif #ifndef ASSIMP_BUILD_NO_AMF_IMPORTER -# include "AMFImporter.hpp" +# include "AMF/AMFImporter.hpp" #endif #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER -# include "3DSLoader.h" +# include "3DS/3DSLoader.h" #endif #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER -# include "MD3Loader.h" +# include "MD3/MD3Loader.h" #endif #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER -# include "MDLLoader.h" +# include "MDL/MDLLoader.h" #endif #ifndef ASSIMP_BUILD_NO_MD2_IMPORTER -# include "MD2Loader.h" +# include "MD2/MD2Loader.h" #endif #ifndef ASSIMP_BUILD_NO_PLY_IMPORTER -# include "PlyLoader.h" +# include "Ply/PlyLoader.h" #endif #ifndef ASSIMP_BUILD_NO_ASE_IMPORTER -# include "ASELoader.h" +# include "ASE/ASELoader.h" #endif #ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER -# include "ObjFileImporter.h" +# include "Obj/ObjFileImporter.h" #endif #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER -# include "HMPLoader.h" +# include "HMP/HMPLoader.h" #endif #ifndef ASSIMP_BUILD_NO_SMD_IMPORTER -# include "SMDLoader.h" +# include "SMD/SMDLoader.h" #endif #ifndef ASSIMP_BUILD_NO_MDC_IMPORTER -# include "MDCLoader.h" +# include "MDC/MDCLoader.h" #endif #ifndef ASSIMP_BUILD_NO_MD5_IMPORTER -# include "MD5Loader.h" +# include "MD5/MD5Loader.h" #endif #ifndef ASSIMP_BUILD_NO_STL_IMPORTER -# include "STLLoader.h" +# include "STL/STLLoader.h" #endif #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER -# include "LWOLoader.h" +# include "LWO/LWOLoader.h" #endif #ifndef ASSIMP_BUILD_NO_DXF_IMPORTER -# include "DXFLoader.h" +# include "DXF/DXFLoader.h" #endif #ifndef ASSIMP_BUILD_NO_NFF_IMPORTER -# include "NFFLoader.h" +# include "NFF/NFFLoader.h" #endif #ifndef ASSIMP_BUILD_NO_RAW_IMPORTER -# include "RawLoader.h" +# include "Raw/RawLoader.h" #endif #ifndef ASSIMP_BUILD_NO_SIB_IMPORTER -# include "SIBImporter.h" +# include "SIB/SIBImporter.h" #endif #ifndef ASSIMP_BUILD_NO_OFF_IMPORTER -# include "OFFLoader.h" +# include "OFF/OFFLoader.h" #endif #ifndef ASSIMP_BUILD_NO_AC_IMPORTER -# include "ACLoader.h" +# include "AC/ACLoader.h" #endif #ifndef ASSIMP_BUILD_NO_BVH_IMPORTER -# include "BVHLoader.h" +# include "BVH/BVHLoader.h" #endif #ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER -# include "IRRMeshLoader.h" +# include "Irr/IRRMeshLoader.h" #endif #ifndef ASSIMP_BUILD_NO_IRR_IMPORTER -# include "IRRLoader.h" +# include "Irr/IRRLoader.h" #endif #ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER -# include "Q3DLoader.h" +# include "Q3D/Q3DLoader.h" #endif #ifndef ASSIMP_BUILD_NO_B3D_IMPORTER -# include "B3DImporter.h" +# include "B3D/B3DImporter.h" #endif #ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER -# include "ColladaLoader.h" +# include "Collada/ColladaLoader.h" #endif #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER -# include "TerragenLoader.h" +# include "Terragen/TerragenLoader.h" #endif #ifndef ASSIMP_BUILD_NO_CSM_IMPORTER -# include "CSMLoader.h" +# include "CSM/CSMLoader.h" #endif #ifndef ASSIMP_BUILD_NO_3D_IMPORTER -# include "UnrealLoader.h" +# include "Unreal/UnrealLoader.h" #endif #ifndef ASSIMP_BUILD_NO_LWS_IMPORTER -# include "LWSLoader.h" +# include "LWS/LWSLoader.h" #endif #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER -# include "OgreImporter.h" +# include "Ogre/OgreImporter.h" #endif #ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER -# include "OpenGEXImporter.h" +# include "OpenGEX/OpenGEXImporter.h" #endif #ifndef ASSIMP_BUILD_NO_MS3D_IMPORTER -# include "MS3DLoader.h" +# include "MS3D/MS3DLoader.h" #endif #ifndef ASSIMP_BUILD_NO_COB_IMPORTER -# include "COBLoader.h" +# include "COB/COBLoader.h" #endif #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER -# include "BlenderLoader.h" +# include "Blender/BlenderLoader.h" #endif #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER -# include "Q3BSPFileImporter.h" +# include "Q3BSP/Q3BSPFileImporter.h" #endif #ifndef ASSIMP_BUILD_NO_NDO_IMPORTER -# include "NDOLoader.h" +# include "NDO/NDOLoader.h" #endif #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER # include "Importer/IFC/IFCLoader.h" #endif #ifndef ASSIMP_BUILD_NO_XGL_IMPORTER -# include "XGLLoader.h" +# include "XGL/XGLLoader.h" #endif #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER -# include "FBXImporter.h" +# include "FBX/FBXImporter.h" #endif #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER -# include "AssbinLoader.h" +# include "Assbin/AssbinLoader.h" #endif #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER -# include "glTFImporter.h" -# include "glTF2Importer.h" +# include "glTF/glTFImporter.h" +# include "glTF2/glTF2Importer.h" #endif #ifndef ASSIMP_BUILD_NO_C4D_IMPORTER -# include "C4DImporter.h" +# include "C4D/C4DImporter.h" #endif #ifndef ASSIMP_BUILD_NO_3MF_IMPORTER -# include "D3MFImporter.h" +# include "3MF/D3MFImporter.h" #endif #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER -# include "X3DImporter.hpp" +# include "X3D/X3DImporter.hpp" #endif #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER -# include "MMDImporter.h" +# include "MMD/MMDImporter.h" #endif #ifndef ASSIMP_BUILD_NO_STEP_IMPORTER # include "Importer/StepFile/StepFileImporter.h" diff --git a/code/PolyTools.h b/code/Common/PolyTools.h similarity index 100% rename from code/PolyTools.h rename to code/Common/PolyTools.h diff --git a/code/PostStepRegistry.cpp b/code/Common/PostStepRegistry.cpp similarity index 83% rename from code/PostStepRegistry.cpp rename to code/Common/PostStepRegistry.cpp index 15b4a2884..ef58f8ddf 100644 --- a/code/PostStepRegistry.cpp +++ b/code/Common/PostStepRegistry.cpp @@ -48,89 +48,93 @@ directly (unless you are adding new steps), instead use the corresponding preprocessor flag to selectively disable steps. */ -#include "ProcessHelper.h" +#include "PostProcessing/ProcessHelper.h" #ifndef ASSIMP_BUILD_NO_CALCTANGENTS_PROCESS -# include "CalcTangentsProcess.h" +# include "PostProcessing/CalcTangentsProcess.h" #endif #ifndef ASSIMP_BUILD_NO_JOINVERTICES_PROCESS -# include "JoinVerticesProcess.h" +# include "PostProcessing/JoinVerticesProcess.h" #endif #if !(defined ASSIMP_BUILD_NO_MAKELEFTHANDED_PROCESS && defined ASSIMP_BUILD_NO_FLIPUVS_PROCESS && defined ASSIMP_BUILD_NO_FLIPWINDINGORDER_PROCESS) -# include "ConvertToLHProcess.h" +# include "PostProcessing/ConvertToLHProcess.h" #endif #ifndef ASSIMP_BUILD_NO_TRIANGULATE_PROCESS -# include "TriangulateProcess.h" +# include "PostProcessing/TriangulateProcess.h" #endif #ifndef ASSIMP_BUILD_NO_DROPFACENORMALS_PROCESS -# include "DropFaceNormalsProcess.h" +# include "PostProcessing/DropFaceNormalsProcess.h" #endif #ifndef ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS -# include "GenFaceNormalsProcess.h" +# include "PostProcessing/GenFaceNormalsProcess.h" #endif #ifndef ASSIMP_BUILD_NO_GENVERTEXNORMALS_PROCESS -# include "GenVertexNormalsProcess.h" +# include "PostProcessing/GenVertexNormalsProcess.h" #endif #ifndef ASSIMP_BUILD_NO_REMOVEVC_PROCESS -# include "RemoveVCProcess.h" +# include "PostProcessing/RemoveVCProcess.h" #endif #ifndef ASSIMP_BUILD_NO_SPLITLARGEMESHES_PROCESS -# include "SplitLargeMeshes.h" +# include "PostProcessing/SplitLargeMeshes.h" #endif #ifndef ASSIMP_BUILD_NO_PRETRANSFORMVERTICES_PROCESS -# include "PretransformVertices.h" +# include "PostProcessing/PretransformVertices.h" #endif #ifndef ASSIMP_BUILD_NO_LIMITBONEWEIGHTS_PROCESS -# include "LimitBoneWeightsProcess.h" +# include "PostProcessing/LimitBoneWeightsProcess.h" #endif #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS -# include "ValidateDataStructure.h" +# include "PostProcessing/ValidateDataStructure.h" #endif #ifndef ASSIMP_BUILD_NO_IMPROVECACHELOCALITY_PROCESS -# include "ImproveCacheLocality.h" +# include "PostProcessing/ImproveCacheLocality.h" #endif #ifndef ASSIMP_BUILD_NO_FIXINFACINGNORMALS_PROCESS -# include "FixNormalsStep.h" +# include "PostProcessing/FixNormalsStep.h" #endif #ifndef ASSIMP_BUILD_NO_REMOVE_REDUNDANTMATERIALS_PROCESS -# include "RemoveRedundantMaterials.h" +# include "PostProcessing/RemoveRedundantMaterials.h" #endif #if (!defined ASSIMP_BUILD_NO_EMBEDTEXTURES_PROCESS) -# include "EmbedTexturesProcess.h" +# include "PostProcessing/EmbedTexturesProcess.h" #endif #ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS -# include "FindInvalidDataProcess.h" +# include "PostProcessing/FindInvalidDataProcess.h" #endif #ifndef ASSIMP_BUILD_NO_FINDDEGENERATES_PROCESS -# include "FindDegenerates.h" +# include "PostProcessing/FindDegenerates.h" #endif #ifndef ASSIMP_BUILD_NO_SORTBYPTYPE_PROCESS -# include "SortByPTypeProcess.h" +# include "PostProcessing/SortByPTypeProcess.h" #endif #ifndef ASSIMP_BUILD_NO_GENUVCOORDS_PROCESS -# include "ComputeUVMappingProcess.h" +# include "PostProcessing/ComputeUVMappingProcess.h" #endif #ifndef ASSIMP_BUILD_NO_TRANSFORMTEXCOORDS_PROCESS -# include "TextureTransform.h" +# include "PostProcessing/TextureTransform.h" #endif #ifndef ASSIMP_BUILD_NO_FINDINSTANCES_PROCESS -# include "FindInstancesProcess.h" +# include "PostProcessing/FindInstancesProcess.h" #endif #ifndef ASSIMP_BUILD_NO_OPTIMIZEMESHES_PROCESS -# include "OptimizeMeshes.h" +# include "PostProcessing/OptimizeMeshes.h" #endif #ifndef ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS -# include "OptimizeGraph.h" +# include "PostProcessing/OptimizeGraph.h" #endif #ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS -# include "SplitByBoneCountProcess.h" +# include "Common/SplitByBoneCountProcess.h" #endif #ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS -# include "DeboneProcess.h" +# include "PostProcessing/DeboneProcess.h" #endif #if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS) -# include "ScaleProcess.h" +# include "PostProcessing/ScaleProcess.h" #endif +#if (!defined ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS) +# include "PostProcessing/GenBoundingBoxesProcess.h" +#endif + namespace Assimp { @@ -246,6 +250,9 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out) #if (!defined ASSIMP_BUILD_NO_IMPROVECACHELOCALITY_PROCESS) out.push_back( new ImproveCacheLocalityProcess()); #endif +#if (!defined ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS) + out.push_back(new GenBoundingBoxesProcess); +#endif } } diff --git a/code/RemoveComments.cpp b/code/Common/RemoveComments.cpp similarity index 100% rename from code/RemoveComments.cpp rename to code/Common/RemoveComments.cpp diff --git a/code/SGSpatialSort.cpp b/code/Common/SGSpatialSort.cpp similarity index 100% rename from code/SGSpatialSort.cpp rename to code/Common/SGSpatialSort.cpp diff --git a/code/SceneCombiner.cpp b/code/Common/SceneCombiner.cpp similarity index 100% rename from code/SceneCombiner.cpp rename to code/Common/SceneCombiner.cpp diff --git a/code/ScenePreprocessor.cpp b/code/Common/ScenePreprocessor.cpp similarity index 100% rename from code/ScenePreprocessor.cpp rename to code/Common/ScenePreprocessor.cpp diff --git a/code/ScenePreprocessor.h b/code/Common/ScenePreprocessor.h similarity index 100% rename from code/ScenePreprocessor.h rename to code/Common/ScenePreprocessor.h diff --git a/code/ScenePrivate.h b/code/Common/ScenePrivate.h similarity index 100% rename from code/ScenePrivate.h rename to code/Common/ScenePrivate.h diff --git a/code/SkeletonMeshBuilder.cpp b/code/Common/SkeletonMeshBuilder.cpp similarity index 100% rename from code/SkeletonMeshBuilder.cpp rename to code/Common/SkeletonMeshBuilder.cpp diff --git a/code/SpatialSort.cpp b/code/Common/SpatialSort.cpp similarity index 100% rename from code/SpatialSort.cpp rename to code/Common/SpatialSort.cpp diff --git a/code/SplitByBoneCountProcess.cpp b/code/Common/SplitByBoneCountProcess.cpp similarity index 100% rename from code/SplitByBoneCountProcess.cpp rename to code/Common/SplitByBoneCountProcess.cpp diff --git a/code/SplitByBoneCountProcess.h b/code/Common/SplitByBoneCountProcess.h similarity index 100% rename from code/SplitByBoneCountProcess.h rename to code/Common/SplitByBoneCountProcess.h diff --git a/code/StandardShapes.cpp b/code/Common/StandardShapes.cpp similarity index 100% rename from code/StandardShapes.cpp rename to code/Common/StandardShapes.cpp diff --git a/code/StdOStreamLogStream.h b/code/Common/StdOStreamLogStream.h similarity index 100% rename from code/StdOStreamLogStream.h rename to code/Common/StdOStreamLogStream.h diff --git a/code/Subdivision.cpp b/code/Common/Subdivision.cpp similarity index 99% rename from code/Subdivision.cpp rename to code/Common/Subdivision.cpp index 19db223a5..60c54939f 100644 --- a/code/Subdivision.cpp +++ b/code/Common/Subdivision.cpp @@ -43,9 +43,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include "ProcessHelper.h" #include #include + +#include "PostProcessing/ProcessHelper.h" + #include using namespace Assimp; @@ -56,8 +58,7 @@ void mydummy() {} * implementation is basing on recursive refinement. Directly evaluating the result is also * possible and much quicker, but it depends on lengthy matrix lookup tables. */ // ------------------------------------------------------------------------------------------------ -class CatmullClarkSubdivider : public Subdivider -{ +class CatmullClarkSubdivider : public Subdivider { public: void Subdivide (aiMesh* mesh, aiMesh*& out, unsigned int num, bool discard_input); void Subdivide (aiMesh** smesh, size_t nmesh, diff --git a/code/TargetAnimation.cpp b/code/Common/TargetAnimation.cpp similarity index 100% rename from code/TargetAnimation.cpp rename to code/Common/TargetAnimation.cpp diff --git a/code/TargetAnimation.h b/code/Common/TargetAnimation.h similarity index 100% rename from code/TargetAnimation.h rename to code/Common/TargetAnimation.h diff --git a/code/Version.cpp b/code/Common/Version.cpp similarity index 100% rename from code/Version.cpp rename to code/Common/Version.cpp diff --git a/code/VertexTriangleAdjacency.cpp b/code/Common/VertexTriangleAdjacency.cpp similarity index 100% rename from code/VertexTriangleAdjacency.cpp rename to code/Common/VertexTriangleAdjacency.cpp diff --git a/code/VertexTriangleAdjacency.h b/code/Common/VertexTriangleAdjacency.h similarity index 100% rename from code/VertexTriangleAdjacency.h rename to code/Common/VertexTriangleAdjacency.h diff --git a/code/Win32DebugLogStream.h b/code/Common/Win32DebugLogStream.h similarity index 100% rename from code/Win32DebugLogStream.h rename to code/Common/Win32DebugLogStream.h diff --git a/code/assbin_chunks.h b/code/Common/assbin_chunks.h similarity index 100% rename from code/assbin_chunks.h rename to code/Common/assbin_chunks.h diff --git a/code/scene.cpp b/code/Common/scene.cpp similarity index 100% rename from code/scene.cpp rename to code/Common/scene.cpp diff --git a/code/simd.cpp b/code/Common/simd.cpp similarity index 100% rename from code/simd.cpp rename to code/Common/simd.cpp diff --git a/code/simd.h b/code/Common/simd.h similarity index 100% rename from code/simd.h rename to code/Common/simd.h diff --git a/code/DXFHelper.h b/code/DXF/DXFHelper.h similarity index 100% rename from code/DXFHelper.h rename to code/DXF/DXFHelper.h diff --git a/code/DXFLoader.cpp b/code/DXF/DXFLoader.cpp similarity index 99% rename from code/DXFLoader.cpp rename to code/DXF/DXFLoader.cpp index ab86f89ae..baf315485 100644 --- a/code/DXFLoader.cpp +++ b/code/DXF/DXFLoader.cpp @@ -48,12 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_DXF_IMPORTER -#include "DXFLoader.h" -#include -#include "ConvertToLHProcess.h" -#include +#include "DXF/DXFLoader.h" +#include "DXF/DXFHelper.h" +#include "PostProcessing/ConvertToLHProcess.h" -#include "DXFHelper.h" +#include +#include #include #include #include diff --git a/code/DXFLoader.h b/code/DXF/DXFLoader.h similarity index 100% rename from code/DXFLoader.h rename to code/DXF/DXFLoader.h diff --git a/code/FBXAnimation.cpp b/code/FBX/FBXAnimation.cpp similarity index 100% rename from code/FBXAnimation.cpp rename to code/FBX/FBXAnimation.cpp diff --git a/code/FBXBinaryTokenizer.cpp b/code/FBX/FBXBinaryTokenizer.cpp similarity index 97% rename from code/FBXBinaryTokenizer.cpp rename to code/FBX/FBXBinaryTokenizer.cpp index 7138df431..a4a2bc8e7 100644 --- a/code/FBXBinaryTokenizer.cpp +++ b/code/FBX/FBXBinaryTokenizer.cpp @@ -98,7 +98,7 @@ namespace FBX { // return (flags & to_check) != 0; //} // ------------------------------------------------------------------------------------------------ -Token::Token(const char* sbegin, const char* send, TokenType type, unsigned int offset) +Token::Token(const char* sbegin, const char* send, TokenType type, size_t offset) : #ifdef DEBUG contents(sbegin, static_cast(send-sbegin)), @@ -122,18 +122,18 @@ namespace { // ------------------------------------------------------------------------------------------------ // signal tokenization error, this is always unrecoverable. Throws DeadlyImportError. -AI_WONT_RETURN void TokenizeError(const std::string& message, unsigned int offset) AI_WONT_RETURN_SUFFIX; -AI_WONT_RETURN void TokenizeError(const std::string& message, unsigned int offset) +AI_WONT_RETURN void TokenizeError(const std::string& message, size_t offset) AI_WONT_RETURN_SUFFIX; +AI_WONT_RETURN void TokenizeError(const std::string& message, size_t offset) { throw DeadlyImportError(Util::AddOffset("FBX-Tokenize",message,offset)); } // ------------------------------------------------------------------------------------------------ -uint32_t Offset(const char* begin, const char* cursor) { +size_t Offset(const char* begin, const char* cursor) { ai_assert(begin <= cursor); - return static_cast(cursor - begin); + return cursor - begin; } // ------------------------------------------------------------------------------------------------ @@ -424,7 +424,7 @@ bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor, // ------------------------------------------------------------------------------------------------ // TODO: Test FBX Binary files newer than the 7500 version to check if the 64 bits address behaviour is consistent -void TokenizeBinary(TokenList& output_tokens, const char* input, unsigned int length) +void TokenizeBinary(TokenList& output_tokens, const char* input, size_t length) { ai_assert(input); diff --git a/code/FBXCommon.h b/code/FBX/FBXCommon.h similarity index 100% rename from code/FBXCommon.h rename to code/FBX/FBXCommon.h diff --git a/code/FBXCompileConfig.h b/code/FBX/FBXCompileConfig.h similarity index 100% rename from code/FBXCompileConfig.h rename to code/FBX/FBXCompileConfig.h diff --git a/code/FBXConverter.cpp b/code/FBX/FBXConverter.cpp similarity index 98% rename from code/FBXConverter.cpp rename to code/FBX/FBXConverter.cpp index 5f7835461..fc9c8b299 100644 --- a/code/FBXConverter.cpp +++ b/code/FBX/FBXConverter.cpp @@ -86,7 +86,6 @@ namespace Assimp { , textures_converted() , meshes_converted() , node_anim_chain_bits() - , mNodeNameInstances() , mNodeNames() , anim_fps() , out(out) @@ -142,12 +141,46 @@ namespace Assimp { void FBXConverter::ConvertRootNode() { out->mRootNode = new aiNode(); - out->mRootNode->mName.Set("RootNode"); + std::string unique_name; + GetUniqueName("RootNode", unique_name); + out->mRootNode->mName.Set(unique_name); // root has ID 0 ConvertNodes(0L, *out->mRootNode); } + static std::string getAncestorBaseName(const aiNode* node) + { + const char* nodeName = nullptr; + size_t length = 0; + while (node && (!nodeName || length == 0)) + { + nodeName = node->mName.C_Str(); + length = node->mName.length; + node = node->mParent; + } + + if (!nodeName || length == 0) + { + return {}; + } + // could be std::string_view if c++17 available + return std::string(nodeName, length); + } + + // Make unique name + std::string FBXConverter::MakeUniqueNodeName(const Model* const model, const aiNode& parent) + { + std::string original_name = FixNodeName(model->Name()); + if (original_name.empty()) + { + original_name = getAncestorBaseName(&parent); + } + std::string unique_name; + GetUniqueName(original_name, unique_name); + return unique_name; + } + void FBXConverter::ConvertNodes(uint64_t id, aiNode& parent, const aiMatrix4x4& parent_transform) { const std::vector& conns = doc.GetConnectionsByDestinationSequenced(id, "Model"); @@ -179,35 +212,18 @@ namespace Assimp { aiMatrix4x4 new_abs_transform = parent_transform; + std::string unique_name = MakeUniqueNodeName(model, parent); + // even though there is only a single input node, the design of // assimp (or rather: the complicated transformation chain that // is employed by fbx) means that we may need multiple aiNode's // to represent a fbx node's transformation. - GenerateTransformationNodeChain(*model, nodes_chain, post_nodes_chain); + const bool need_additional_node = GenerateTransformationNodeChain(*model, unique_name, nodes_chain, post_nodes_chain); ai_assert(nodes_chain.size()); - std::string original_name = FixNodeName(model->Name()); - - // check if any of the nodes in the chain has the name the fbx node - // is supposed to have. If there is none, add another node to - // preserve the name - people might have scripts etc. that rely - // on specific node names. - aiNode* name_carrier = NULL; - for (aiNode* prenode : nodes_chain) { - if (!strcmp(prenode->mName.C_Str(), original_name.c_str())) { - name_carrier = prenode; - break; - } - } - - if (!name_carrier) { - std::string old_original_name = original_name; - GetUniqueName(old_original_name, original_name); - nodes_chain.push_back(new aiNode(original_name)); - } - else { - original_name = nodes_chain.back()->mName.C_Str(); + if (need_additional_node) { + nodes_chain.push_back(new aiNode(unique_name)); } //setup metadata on newest node @@ -269,11 +285,11 @@ namespace Assimp { ConvertNodes(model->ID(), *last_parent, new_abs_transform); if (doc.Settings().readLights) { - ConvertLights(*model, original_name); + ConvertLights(*model, unique_name); } if (doc.Settings().readCameras) { - ConvertCameras(*model, original_name); + ConvertCameras(*model, unique_name); } nodes.push_back(nodes_chain.front()); @@ -426,21 +442,16 @@ namespace Assimp { void FBXConverter::GetUniqueName(const std::string &name, std::string &uniqueName) { uniqueName = name; - int i = 0; - auto it = mNodeNameInstances.find(name); // duplicate node name instance count - if (it != mNodeNameInstances.end()) + auto it_pair = mNodeNames.insert({ name, 0 }); // duplicate node name instance count + unsigned int& i = it_pair.first->second; + while (!it_pair.second) { - i = it->second; - while (mNodeNames.find(uniqueName) != mNodeNames.end()) - { - i++; - std::stringstream ext; - ext << name << std::setfill('0') << std::setw(3) << i; - uniqueName = ext.str(); - } + i++; + std::ostringstream ext; + ext << name << std::setfill('0') << std::setw(3) << i; + uniqueName = ext.str(); + it_pair = mNodeNames.insert({ uniqueName, 0 }); } - mNodeNameInstances[name] = i; - mNodeNames.insert(uniqueName); } const char* FBXConverter::NameTransformationComp(TransformationComp comp) { @@ -672,7 +683,7 @@ namespace Assimp { return name + std::string(MAGIC_NODE_TAG) + "_" + NameTransformationComp(comp); } - void FBXConverter::GenerateTransformationNodeChain(const Model& model, std::vector& output_nodes, + bool FBXConverter::GenerateTransformationNodeChain(const Model& model, const std::string& name, std::vector& output_nodes, std::vector& post_output_nodes) { const PropertyTable& props = model.Props(); const Model::RotOrder rot = model.RotationOrder(); @@ -787,8 +798,6 @@ namespace Assimp { // not be guaranteed. ai_assert(NeedsComplexTransformationChain(model) == is_complex); - std::string name = FixNodeName(model.Name()); - // now, if we have more than just Translation, Scaling and Rotation, // we need to generate a full node chain to accommodate for assimp's // lack to express pivots and offsets. @@ -830,20 +839,20 @@ namespace Assimp { } ai_assert(output_nodes.size()); - return; + return true; } // else, we can just multiply the matrices together aiNode* nd = new aiNode(); output_nodes.push_back(nd); - std::string uniqueName; - GetUniqueName(name, uniqueName); - nd->mName.Set(uniqueName); + // name passed to the method is already unique + nd->mName.Set(name); for (const auto &transform : chain) { nd->mTransformation = nd->mTransformation * transform; } + return false; } void FBXConverter::SetupNodeMetadata(const Model& model, aiNode& nd) @@ -1246,7 +1255,7 @@ namespace Assimp { // mapping from output indices to DOM indexing, needed to resolve weights std::vector reverseMapping; - + std::map translateIndexMap; if (process_weights) { reverseMapping.resize(count_vertices); } @@ -1354,6 +1363,7 @@ namespace Assimp { if (reverseMapping.size()) { reverseMapping[cursor] = in_cursor; + translateIndexMap[in_cursor] = cursor; } out_mesh->mVertices[cursor] = vertices[in_cursor]; @@ -1386,7 +1396,10 @@ namespace Assimp { } std::vector animMeshes; +<<<<<<< HEAD:code/FBXConverter.cpp size_t bsIdx(0), bsChannelIdx(0); +======= +>>>>>>> master:code/FBX/FBXConverter.cpp for (const BlendShape* blendShape : mesh.GetBlendShapes()) { for (const BlendShapeChannel* blendShapeChannel : blendShape->BlendShapeChannels()) { const std::vector& shapeGeometries = blendShapeChannel->GetShapeGeometries(); @@ -1404,7 +1417,12 @@ namespace Assimp { unsigned int count = 0; const unsigned int* outIndices = mesh.ToOutputVertexIndex(index, count); for (unsigned int k = 0; k < count; k++) { +<<<<<<< HEAD:code/FBXConverter.cpp unsigned int index = outIndices[k]; +======= + unsigned int index = translateIndexMap[outIndices[k]]; + +>>>>>>> master:code/FBX/FBXConverter.cpp animMesh->mVertices[index] += vertex; if (animMesh->mNormals != nullptr) { animMesh->mNormals[index] += normal; @@ -1415,6 +1433,7 @@ namespace Assimp { animMesh->mWeight = shapeGeometries.size() > 1 ? blendShapeChannel->DeformPercent() / 100.0f : 1.0f; animMeshes.push_back(animMesh); } +<<<<<<< HEAD:code/FBXConverter.cpp bsChannelIdx++; } bsIdx++; @@ -1426,6 +1445,8 @@ namespace Assimp { out_mesh->mAnimMeshes = new aiAnimMesh * [numAnimMeshes]; for (size_t i = 0; i < numAnimMeshes; i++) { out_mesh->mAnimMeshes[i] = animMeshes.at(i); +======= +>>>>>>> master:code/FBX/FBXConverter.cpp } } @@ -1677,7 +1698,7 @@ namespace Assimp { out_tex->pcData = reinterpret_cast(const_cast(video).RelinquishContent()); // try to extract a hint from the file extension - const std::string& filename = video.FileName().empty() ? video.RelativeFilename() : video.FileName(); + const std::string& filename = video.RelativeFilename().empty() ? video.FileName() : video.RelativeFilename(); std::string ext = BaseImporter::GetExtension(filename); if (ext == "jpeg") { @@ -1688,7 +1709,7 @@ namespace Assimp { memcpy(out_tex->achFormatHint, ext.c_str(), ext.size()); } - out_tex->mFilename.Set(video.FileName().c_str()); + out_tex->mFilename.Set(filename.c_str()); return static_cast(textures.size() - 1); } diff --git a/code/FBXConverter.h b/code/FBX/FBXConverter.h similarity index 97% rename from code/FBXConverter.h rename to code/FBX/FBXConverter.h index 1aa7e13ea..17a7bc56b 100644 --- a/code/FBXConverter.h +++ b/code/FBX/FBXConverter.h @@ -155,6 +155,11 @@ private: // while these would be allowed, they are a potential trouble spot so better not use them). const char* NameTransformationComp(TransformationComp comp); + // ------------------------------------------------------------------------------------------------ + // Returns an unique name for a node or traverses up a hierarchy until a non-empty name is found and + // then makes this name unique + std::string MakeUniqueNodeName(const Model* const model, const aiNode& parent); + // ------------------------------------------------------------------------------------------------ // note: this returns the REAL fbx property names const char* NameTransformationCompProperty(TransformationComp comp); @@ -178,7 +183,7 @@ private: /** * note: memory for output_nodes will be managed by the caller */ - void GenerateTransformationNodeChain(const Model& model, std::vector& output_nodes, std::vector& post_output_nodes); + bool GenerateTransformationNodeChain(const Model& model, const std::string& name, std::vector& output_nodes, std::vector& post_output_nodes); // ------------------------------------------------------------------------------------------------ void SetupNodeMetadata(const Model& model, aiNode& nd); @@ -458,10 +463,7 @@ private: NodeAnimBitMap node_anim_chain_bits; // number of nodes with the same name - using NodeAnimNameMap = std::unordered_map; - NodeAnimNameMap mNodeNameInstances; - - using NodeNameCache = std::unordered_set; + using NodeNameCache = std::unordered_map; NodeNameCache mNodeNames; double anim_fps; diff --git a/code/FBXDeformer.cpp b/code/FBX/FBXDeformer.cpp similarity index 100% rename from code/FBXDeformer.cpp rename to code/FBX/FBXDeformer.cpp diff --git a/code/FBXDocument.cpp b/code/FBX/FBXDocument.cpp similarity index 100% rename from code/FBXDocument.cpp rename to code/FBX/FBXDocument.cpp diff --git a/code/FBXDocument.h b/code/FBX/FBXDocument.h similarity index 99% rename from code/FBXDocument.h rename to code/FBX/FBXDocument.h index c849defdc..53bd65878 100644 --- a/code/FBXDocument.h +++ b/code/FBX/FBXDocument.h @@ -643,7 +643,7 @@ private: std::string fileName; std::shared_ptr props; - uint32_t contentLength; + uint64_t contentLength; uint8_t* content; }; diff --git a/code/FBXDocumentUtil.cpp b/code/FBX/FBXDocumentUtil.cpp similarity index 100% rename from code/FBXDocumentUtil.cpp rename to code/FBX/FBXDocumentUtil.cpp diff --git a/code/FBXDocumentUtil.h b/code/FBX/FBXDocumentUtil.h similarity index 100% rename from code/FBXDocumentUtil.h rename to code/FBX/FBXDocumentUtil.h diff --git a/code/FBXExportNode.cpp b/code/FBX/FBXExportNode.cpp similarity index 100% rename from code/FBXExportNode.cpp rename to code/FBX/FBXExportNode.cpp diff --git a/code/FBXExportNode.h b/code/FBX/FBXExportNode.h similarity index 100% rename from code/FBXExportNode.h rename to code/FBX/FBXExportNode.h diff --git a/code/FBXExportProperty.cpp b/code/FBX/FBXExportProperty.cpp similarity index 100% rename from code/FBXExportProperty.cpp rename to code/FBX/FBXExportProperty.cpp diff --git a/code/FBXExportProperty.h b/code/FBX/FBXExportProperty.h similarity index 100% rename from code/FBXExportProperty.h rename to code/FBX/FBXExportProperty.h diff --git a/code/FBXExporter.cpp b/code/FBX/FBXExporter.cpp similarity index 100% rename from code/FBXExporter.cpp rename to code/FBX/FBXExporter.cpp diff --git a/code/FBXExporter.h b/code/FBX/FBXExporter.h similarity index 100% rename from code/FBXExporter.h rename to code/FBX/FBXExporter.h diff --git a/code/FBXImportSettings.h b/code/FBX/FBXImportSettings.h similarity index 100% rename from code/FBXImportSettings.h rename to code/FBX/FBXImportSettings.h diff --git a/code/FBXImporter.cpp b/code/FBX/FBXImporter.cpp similarity index 98% rename from code/FBXImporter.cpp rename to code/FBX/FBXImporter.cpp index 988735a77..ec8bbd2b4 100644 --- a/code/FBXImporter.cpp +++ b/code/FBX/FBXImporter.cpp @@ -172,7 +172,7 @@ void FBXImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS bool is_binary = false; if (!strncmp(begin,"Kaydara FBX Binary",18)) { is_binary = true; - TokenizeBinary(tokens,begin,static_cast(contents.size())); + TokenizeBinary(tokens,begin,contents.size()); } else { Tokenize(tokens,begin); diff --git a/code/FBXImporter.h b/code/FBX/FBXImporter.h similarity index 100% rename from code/FBXImporter.h rename to code/FBX/FBXImporter.h diff --git a/code/FBXMaterial.cpp b/code/FBX/FBXMaterial.cpp similarity index 85% rename from code/FBXMaterial.cpp rename to code/FBX/FBXMaterial.cpp index f16f13440..f43a8b84b 100644 --- a/code/FBXMaterial.cpp +++ b/code/FBX/FBXMaterial.cpp @@ -316,7 +316,7 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std relativeFileName = ParseTokenAsString(GetRequiredToken(*RelativeFilename,0)); } - if(Content) { + if(Content && !Content->Tokens().empty()) { //this field is omitted when the embedded texture is already loaded, let's ignore if it's not found try { const Token& token = GetRequiredToken(*Content, 0); @@ -326,16 +326,40 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std DOMError("embedded content is not surrounded by quotation marks", &element); } else { - const char* encodedData = data + 1; - size_t encodedDataLen = static_cast(token.end() - token.begin()); - // search for last quotation mark - while (encodedDataLen > 1 && encodedData[encodedDataLen] != '"') - encodedDataLen--; - if (encodedDataLen % 4 != 0) { - DOMError("embedded content is invalid, needs to be in base64", &element); + size_t targetLength = 0; + auto numTokens = Content->Tokens().size(); + // First time compute size (it could be large like 64Gb and it is good to allocate it once) + for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx) + { + const Token& dataToken = GetRequiredToken(*Content, tokenIdx); + size_t tokenLength = dataToken.end() - dataToken.begin() - 2; // ignore double quotes + const char* base64data = dataToken.begin() + 1; + const size_t outLength = Util::ComputeDecodedSizeBase64(base64data, tokenLength); + if (outLength == 0) + { + DOMError("Corrupted embedded content found", &element); + } + targetLength += outLength; } - else { - contentLength = Util::DecodeBase64(encodedData, encodedDataLen, content); + if (targetLength == 0) + { + DOMError("Corrupted embedded content found", &element); + } + content = new uint8_t[targetLength]; + contentLength = static_cast(targetLength); + size_t dst_offset = 0; + for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx) + { + const Token& dataToken = GetRequiredToken(*Content, tokenIdx); + size_t tokenLength = dataToken.end() - dataToken.begin() - 2; // ignore double quotes + const char* base64data = dataToken.begin() + 1; + dst_offset += Util::DecodeBase64(base64data, tokenLength, content + dst_offset, targetLength - dst_offset); + } + if (targetLength != dst_offset) + { + delete[] content; + contentLength = 0; + DOMError("Corrupted embedded content found", &element); } } } diff --git a/code/FBXMeshGeometry.cpp b/code/FBX/FBXMeshGeometry.cpp similarity index 100% rename from code/FBXMeshGeometry.cpp rename to code/FBX/FBXMeshGeometry.cpp diff --git a/code/FBXMeshGeometry.h b/code/FBX/FBXMeshGeometry.h similarity index 100% rename from code/FBXMeshGeometry.h rename to code/FBX/FBXMeshGeometry.h diff --git a/code/FBXModel.cpp b/code/FBX/FBXModel.cpp similarity index 100% rename from code/FBXModel.cpp rename to code/FBX/FBXModel.cpp diff --git a/code/FBXNodeAttribute.cpp b/code/FBX/FBXNodeAttribute.cpp similarity index 100% rename from code/FBXNodeAttribute.cpp rename to code/FBX/FBXNodeAttribute.cpp diff --git a/code/FBXParser.cpp b/code/FBX/FBXParser.cpp similarity index 99% rename from code/FBXParser.cpp rename to code/FBX/FBXParser.cpp index d1f1689c5..4a9346040 100644 --- a/code/FBXParser.cpp +++ b/code/FBX/FBXParser.cpp @@ -643,9 +643,9 @@ void ParseVectorDataArray(std::vector& out, const Element& el) if (type == 'd') { const double* d = reinterpret_cast(&buff[0]); for (unsigned int i = 0; i < count3; ++i, d += 3) { - out.push_back(aiVector3D(static_cast(d[0]), - static_cast(d[1]), - static_cast(d[2]))); + out.push_back(aiVector3D(static_cast(d[0]), + static_cast(d[1]), + static_cast(d[2]))); } // for debugging /*for ( size_t i = 0; i < out.size(); i++ ) { diff --git a/code/FBXParser.h b/code/FBX/FBXParser.h similarity index 100% rename from code/FBXParser.h rename to code/FBX/FBXParser.h diff --git a/code/FBXProperties.cpp b/code/FBX/FBXProperties.cpp similarity index 100% rename from code/FBXProperties.cpp rename to code/FBX/FBXProperties.cpp diff --git a/code/FBXProperties.h b/code/FBX/FBXProperties.h similarity index 100% rename from code/FBXProperties.h rename to code/FBX/FBXProperties.h diff --git a/code/FBXTokenizer.cpp b/code/FBX/FBXTokenizer.cpp similarity index 100% rename from code/FBXTokenizer.cpp rename to code/FBX/FBXTokenizer.cpp diff --git a/code/FBXTokenizer.h b/code/FBX/FBXTokenizer.h similarity index 96% rename from code/FBXTokenizer.h rename to code/FBX/FBXTokenizer.h index 2af29743f..afa588a47 100644 --- a/code/FBXTokenizer.h +++ b/code/FBX/FBXTokenizer.h @@ -93,7 +93,7 @@ public: Token(const char* sbegin, const char* send, TokenType type, unsigned int line, unsigned int column); /** construct a binary token */ - Token(const char* sbegin, const char* send, TokenType type, unsigned int offset); + Token(const char* sbegin, const char* send, TokenType type, size_t offset); ~Token(); @@ -118,14 +118,14 @@ public: return type; } - unsigned int Offset() const { + size_t Offset() const { ai_assert(IsBinary()); return offset; } unsigned int Line() const { ai_assert(!IsBinary()); - return line; + return static_cast(line); } unsigned int Column() const { @@ -147,8 +147,8 @@ private: const TokenType type; union { - const unsigned int line; - unsigned int offset; + size_t line; + size_t offset; }; const unsigned int column; }; @@ -178,7 +178,7 @@ void Tokenize(TokenList& output_tokens, const char* input); * @param input_buffer Binary input buffer to be processed. * @param length Length of input buffer, in bytes. There is no 0-terminal. * @throw DeadlyImportError if something goes wrong */ -void TokenizeBinary(TokenList& output_tokens, const char* input, unsigned int length); +void TokenizeBinary(TokenList& output_tokens, const char* input, size_t length); } // ! FBX diff --git a/code/FBXUtil.cpp b/code/FBX/FBXUtil.cpp similarity index 75% rename from code/FBXUtil.cpp rename to code/FBX/FBXUtil.cpp index 557d0d843..c10e057c8 100644 --- a/code/FBXUtil.cpp +++ b/code/FBX/FBXUtil.cpp @@ -86,7 +86,7 @@ const char* TokenTypeString(TokenType t) // ------------------------------------------------------------------------------------------------ -std::string AddOffset(const std::string& prefix, const std::string& text, unsigned int offset) +std::string AddOffset(const std::string& prefix, const std::string& text, size_t offset) { return static_cast( (Formatter::format() << prefix << " (offset 0x" << std::hex << offset << ") " << text) ); } @@ -114,47 +114,66 @@ std::string AddTokenText(const std::string& prefix, const std::string& text, con text) ); } +// Generated by this formula: T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i; static const uint8_t base64DecodeTable[128] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 64, 0, 0, - 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, - 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0 + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 255, 255, 255, + 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, + 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255, 255 }; uint8_t DecodeBase64(char ch) { - return base64DecodeTable[size_t(ch)]; + const auto idx = static_cast(ch); + if (idx > 127) + return 255; + return base64DecodeTable[idx]; } -size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out) +size_t ComputeDecodedSizeBase64(const char* in, size_t inLength) { - if (inLength < 4) { - out = 0; + if (inLength < 2) + { return 0; } - - const size_t outLength = (inLength * 3) / 4; - out = new uint8_t[outLength]; - memset(out, 0, outLength); - - size_t i = 0; - size_t j = 0; - for (i = 0; i < inLength - 4; i += 4) + const size_t equals = size_t(in[inLength - 1] == '=') + size_t(in[inLength - 2] == '='); + const size_t full_length = (inLength * 3) >> 2; // div by 4 + if (full_length < equals) { - uint8_t b0 = Util::DecodeBase64(in[i]); - uint8_t b1 = Util::DecodeBase64(in[i + 1]); - uint8_t b2 = Util::DecodeBase64(in[i + 2]); - uint8_t b3 = Util::DecodeBase64(in[i + 3]); - - out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4)); - out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2)); - out[j++] = (uint8_t)((b2 << 6) | b3); + return 0; } - return outLength; + return full_length - equals; +} + +size_t DecodeBase64(const char* in, size_t inLength, uint8_t* out, size_t maxOutLength) +{ + if (maxOutLength == 0 || inLength < 2) { + return 0; + } + const size_t realLength = inLength - size_t(in[inLength - 1] == '=') - size_t(in[inLength - 2] == '='); + size_t dst_offset = 0; + int val = 0, valb = -8; + for (size_t src_offset = 0; src_offset < realLength; ++src_offset) + { + const uint8_t table_value = Util::DecodeBase64(in[src_offset]); + if (table_value == 255) + { + return 0; + } + val = (val << 6) + table_value; + valb += 6; + if (valb >= 0) + { + out[dst_offset++] = static_cast((val >> valb) & 0xFF); + valb -= 8; + val &= 0xFFF; + } + } + return dst_offset; } static const char to_base64_string[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; diff --git a/code/FBXUtil.h b/code/FBX/FBXUtil.h similarity index 89% rename from code/FBXUtil.h rename to code/FBX/FBXUtil.h index b26eba5d5..b63441885 100644 --- a/code/FBXUtil.h +++ b/code/FBX/FBXUtil.h @@ -78,7 +78,7 @@ const char* TokenTypeString(TokenType t); * @param line Line index, 1-based * @param column Column index, 1-based * @return A string of the following format: {prefix} (offset 0x{offset}) {text}*/ -std::string AddOffset(const std::string& prefix, const std::string& text, unsigned int offset); +std::string AddOffset(const std::string& prefix, const std::string& text, size_t offset); /** Format log/error messages using a given line location in the source file. @@ -105,13 +105,21 @@ std::string AddTokenText(const std::string& prefix, const std::string& text, con * @return decoded byte value*/ uint8_t DecodeBase64(char ch); +/** Compute decoded size of a Base64-encoded string +* +* @param in Characters to decode. +* @param inLength Number of characters to decode. +* @return size of the decoded data (number of bytes)*/ +size_t ComputeDecodedSizeBase64(const char* in, size_t inLength); + /** Decode a Base64-encoded string * * @param in Characters to decode. * @param inLength Number of characters to decode. -* @param out Reference to pointer where we will store the decoded data. +* @param out Pointer where we will store the decoded data. +* @param maxOutLength Size of output buffer. * @return size of the decoded data (number of bytes)*/ -size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out); +size_t DecodeBase64(const char* in, size_t inLength, uint8_t* out, size_t maxOutLength); char EncodeBase64(char byte); diff --git a/code/HMPFileData.h b/code/HMP/HMPFileData.h similarity index 100% rename from code/HMPFileData.h rename to code/HMP/HMPFileData.h diff --git a/code/HMPLoader.cpp b/code/HMP/HMPLoader.cpp similarity index 99% rename from code/HMPLoader.cpp rename to code/HMP/HMPLoader.cpp index 7c1d0b65f..d5469181e 100644 --- a/code/HMPLoader.cpp +++ b/code/HMP/HMPLoader.cpp @@ -47,14 +47,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER // internal headers -#include "HMPLoader.h" -#include "MD2FileData.h" -#include +#include "HMP/HMPLoader.h" +#include "MD2/MD2FileData.h" + #include #include #include #include +#include + using namespace Assimp; static const aiImporterDesc desc = { diff --git a/code/HMPLoader.h b/code/HMP/HMPLoader.h similarity index 98% rename from code/HMPLoader.h rename to code/HMP/HMPLoader.h index d0a34bfb7..421826c91 100644 --- a/code/HMPLoader.h +++ b/code/HMP/HMPLoader.h @@ -48,8 +48,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // internal headers #include -#include "MDLLoader.h" -#include "HMPFileData.h" + +#include "MDL/MDLLoader.h" +#include "HMP/HMPFileData.h" namespace Assimp { using namespace HMP; diff --git a/code/HalfLifeFileData.h b/code/HMP/HalfLifeFileData.h similarity index 100% rename from code/HalfLifeFileData.h rename to code/HMP/HalfLifeFileData.h diff --git a/code/Importer/IFC/IFCBoolean.cpp b/code/Importer/IFC/IFCBoolean.cpp index 337e1d40b..10e7bf3af 100644 --- a/code/Importer/IFC/IFCBoolean.cpp +++ b/code/Importer/IFC/IFCBoolean.cpp @@ -44,8 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER #include "code/Importer/IFC/IFCUtil.h" -#include "code/PolyTools.h" -#include "code/ProcessHelper.h" +#include "code/Common/PolyTools.h" +#include "code/PostProcessing/ProcessHelper.h" #include #include @@ -256,7 +256,7 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const for( size_t i = 0, bcount = boundary.size(); i < bcount; ++i ) { IfcVector3 b01 = boundary[(i + 1) % bcount] - boundary[i]; IfcVector3 b12 = boundary[(i + 2) % bcount] - boundary[(i + 1) % bcount]; - IfcVector3 b1_side = IfcVector3(b01.y, -b01.x, 0.0); // rotated 90° clockwise in Z plane + IfcVector3 b1_side = IfcVector3(b01.y, -b01.x, 0.0); // rotated 90° clockwise in Z plane // Warning: rough estimate only. A concave poly with lots of small segments each featuring a small counter rotation // could fool the accumulation. Correct implementation would be sum( acos( b01 * b2) * sign( b12 * b1_side)) windingOrder += (b1_side.x*b12.x + b1_side.y*b12.y); diff --git a/code/Importer/IFC/IFCGeometry.cpp b/code/Importer/IFC/IFCGeometry.cpp index 548de4e27..032030112 100644 --- a/code/Importer/IFC/IFCGeometry.cpp +++ b/code/Importer/IFC/IFCGeometry.cpp @@ -46,17 +46,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER #include "IFCUtil.h" -#include "code/PolyTools.h" -#include "code/ProcessHelper.h" +#include "Common/PolyTools.h" +#include "PostProcessing/ProcessHelper.h" + +#ifdef ASSIMP_USE_HUNTER +# include +# include +#else +# include "../contrib/poly2tri/poly2tri/poly2tri.h" +# include "../contrib/clipper/clipper.hpp" +#endif -#include "../contrib/poly2tri/poly2tri/poly2tri.h" -#include "../contrib/clipper/clipper.hpp" #include - #include namespace Assimp { - namespace IFC { +namespace IFC { // ------------------------------------------------------------------------------------------------ bool ProcessPolyloop(const Schema_2x3::IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/) diff --git a/code/Importer/IFC/IFCLoader.cpp b/code/Importer/IFC/IFCLoader.cpp index 368f98ec0..5c705c256 100644 --- a/code/Importer/IFC/IFCLoader.cpp +++ b/code/Importer/IFC/IFCLoader.cpp @@ -52,7 +52,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC -# include +# ifdef ASSIMP_USE_HUNTER +# include +# else +# include +# endif #endif #include "IFCLoader.h" diff --git a/code/Importer/IFC/IFCOpenings.cpp b/code/Importer/IFC/IFCOpenings.cpp index c5720e943..a24ffb4ca 100644 --- a/code/Importer/IFC/IFCOpenings.cpp +++ b/code/Importer/IFC/IFCOpenings.cpp @@ -46,11 +46,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER #include "IFCUtil.h" -#include "code/PolyTools.h" -#include "code/ProcessHelper.h" +#include "Common/PolyTools.h" +#include "PostProcessing/ProcessHelper.h" -#include "../contrib/poly2tri/poly2tri/poly2tri.h" -#include "../contrib/clipper/clipper.hpp" +#ifdef ASSIMP_USE_HUNTER +# include +# include +#else +# include "../contrib/poly2tri/poly2tri/poly2tri.h" +# include "../contrib/clipper/clipper.hpp" +#endif #include diff --git a/code/Importer/IFC/IFCReaderGen_2x3.h b/code/Importer/IFC/IFCReaderGen_2x3.h index 0362d90b2..8b39ccdc2 100644 --- a/code/Importer/IFC/IFCReaderGen_2x3.h +++ b/code/Importer/IFC/IFCReaderGen_2x3.h @@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef INCLUDED_IFC_READER_GEN_H #define INCLUDED_IFC_READER_GEN_H -#include "code/STEPFile.h" +#include "code/Step/STEPFile.h" namespace Assimp { namespace IFC { diff --git a/code/Importer/IFC/IFCUtil.cpp b/code/Importer/IFC/IFCUtil.cpp index b9a8538b0..f6bca91f5 100644 --- a/code/Importer/IFC/IFCUtil.cpp +++ b/code/Importer/IFC/IFCUtil.cpp @@ -44,21 +44,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * @brief Implementation of conversion routines for some common Ifc helper entities. */ - - #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER -#include "code/Importer/IFC/IFCUtil.h" -#include "code/PolyTools.h" -#include "code/ProcessHelper.h" +#include "Importer/IFC/IFCUtil.h" +#include "Common/PolyTools.h" +#include "PostProcessing/ProcessHelper.h" #include namespace Assimp { - namespace IFC { +namespace IFC { // ------------------------------------------------------------------------------------------------ -void TempOpening::Transform(const IfcMatrix4& mat) -{ +void TempOpening::Transform(const IfcMatrix4& mat) { if(profileMesh) { profileMesh->Transform(mat); } diff --git a/code/Importer/IFC/IFCUtil.h b/code/Importer/IFC/IFCUtil.h index 17051210e..32ae1e07f 100644 --- a/code/Importer/IFC/IFCUtil.h +++ b/code/Importer/IFC/IFCUtil.h @@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "IFCReaderGen_2x3.h" #include "IFCLoader.h" -#include "code/STEPFile.h" +#include "code/Step/STEPFile.h" #include #include diff --git a/code/Importer/STEPParser/STEPFileEncoding.cpp b/code/Importer/STEPParser/STEPFileEncoding.cpp index 1d7ac3418..101dcdfd7 100644 --- a/code/Importer/STEPParser/STEPFileEncoding.cpp +++ b/code/Importer/STEPParser/STEPFileEncoding.cpp @@ -45,7 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "STEPFileEncoding.h" #include -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif #include diff --git a/code/Importer/STEPParser/STEPFileReader.h b/code/Importer/STEPParser/STEPFileReader.h index 8fc462749..9c4b77241 100644 --- a/code/Importer/STEPParser/STEPFileReader.h +++ b/code/Importer/STEPParser/STEPFileReader.h @@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef INCLUDED_AI_STEPFILEREADER_H #define INCLUDED_AI_STEPFILEREADER_H -#include "code/STEPFile.h" +#include "code/Step/STEPFile.h" namespace Assimp { namespace STEP { diff --git a/code/Importer/StepFile/StepReaderGen.h b/code/Importer/StepFile/StepReaderGen.h index 21f2518df..9eb86c332 100644 --- a/code/Importer/StepFile/StepReaderGen.h +++ b/code/Importer/StepFile/StepReaderGen.h @@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef INCLUDED_STEPFILE_READER_GEN_H #define INCLUDED_STEPFILE_READER_GEN_H -#include "code/STEPFile.h" +#include "code/Step/STEPFile.h" namespace Assimp { namespace StepFile { diff --git a/code/IRRLoader.cpp b/code/Irr/IRRLoader.cpp similarity index 99% rename from code/IRRLoader.cpp rename to code/Irr/IRRLoader.cpp index 796b73164..e94fd85a4 100644 --- a/code/IRRLoader.cpp +++ b/code/Irr/IRRLoader.cpp @@ -49,18 +49,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_IRR_IMPORTER -#include "IRRLoader.h" +#include "Irr/IRRLoader.h" +#include "Common/Importer.h" + #include #include #include - #include #include -#include "Importer.h" - -// We need MathFunctions.h to compute the lcm/gcd of a number #include -#include #include #include #include @@ -69,6 +66,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include +#include + using namespace Assimp; using namespace irr; using namespace irr::io; diff --git a/code/IRRLoader.h b/code/Irr/IRRLoader.h similarity index 94% rename from code/IRRLoader.h rename to code/Irr/IRRLoader.h index e245a0a6f..b3ad81a7d 100644 --- a/code/IRRLoader.h +++ b/code/Irr/IRRLoader.h @@ -48,15 +48,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_IRRLOADER_H_INCLUDED #define AI_IRRLOADER_H_INCLUDED -#include "IRRShared.h" +#include "Irr/IRRShared.h" +#include "Common/Importer.h" + #include -#include "Importer.h" #include #include namespace Assimp { - // --------------------------------------------------------------------------- /** Irr importer class. * @@ -64,15 +64,11 @@ namespace Assimp { * irrEdit. As IrrEdit itself is capable of importing quite many file formats, * it might be a good file format for data exchange. */ -class IRRImporter : public BaseImporter, public IrrlichtBase -{ +class IRRImporter : public BaseImporter, public IrrlichtBase { public: IRRImporter(); ~IRRImporter(); - -public: - // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. * See BaseImporter::CanRead() for details. @@ -81,32 +77,17 @@ public: bool checkSig) const; protected: - - // ------------------------------------------------------------------- - /** - */ const aiImporterDesc* GetInfo () const; - - // ------------------------------------------------------------------- - /** - */ - void InternReadFile( const std::string& pFile, aiScene* pScene, - IOSystem* pIOHandler); - - // ------------------------------------------------------------------- - /** - */ + void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler); void SetupProperties(const Importer* pImp); private: /** Data structure for a scenegraph node animator */ - struct Animator - { + struct Animator { // Type of the animator - enum AT - { + enum AT { UNKNOWN = 0x0, ROTATION = 0x1, FLY_CIRCLE = 0x2, diff --git a/code/IRRMeshLoader.cpp b/code/Irr/IRRMeshLoader.cpp similarity index 100% rename from code/IRRMeshLoader.cpp rename to code/Irr/IRRMeshLoader.cpp diff --git a/code/IRRMeshLoader.h b/code/Irr/IRRMeshLoader.h similarity index 100% rename from code/IRRMeshLoader.h rename to code/Irr/IRRMeshLoader.h diff --git a/code/IRRShared.cpp b/code/Irr/IRRShared.cpp similarity index 100% rename from code/IRRShared.cpp rename to code/Irr/IRRShared.cpp diff --git a/code/IRRShared.h b/code/Irr/IRRShared.h similarity index 100% rename from code/IRRShared.h rename to code/Irr/IRRShared.h diff --git a/code/LWOAnimation.cpp b/code/LWO/LWOAnimation.cpp similarity index 100% rename from code/LWOAnimation.cpp rename to code/LWO/LWOAnimation.cpp diff --git a/code/LWOAnimation.h b/code/LWO/LWOAnimation.h similarity index 100% rename from code/LWOAnimation.h rename to code/LWO/LWOAnimation.h diff --git a/code/LWOBLoader.cpp b/code/LWO/LWOBLoader.cpp similarity index 100% rename from code/LWOBLoader.cpp rename to code/LWO/LWOBLoader.cpp diff --git a/code/LWOFileData.h b/code/LWO/LWOFileData.h similarity index 99% rename from code/LWOFileData.h rename to code/LWO/LWOFileData.h index a702d9363..7d1f6b1df 100644 --- a/code/LWOFileData.h +++ b/code/LWO/LWOFileData.h @@ -57,8 +57,8 @@ The chunks are taken from the official LightWave SDK headers. #include // internal headers -#include "IFF.h" -#include "LWOAnimation.h" +#include "Common/IFF.h" +#include "LWO/LWOAnimation.h" namespace Assimp { namespace LWO { diff --git a/code/LWOLoader.cpp b/code/LWO/LWOLoader.cpp similarity index 99% rename from code/LWOLoader.cpp rename to code/LWO/LWOLoader.cpp index d1c2641e8..1e5b92c32 100644 --- a/code/LWOLoader.cpp +++ b/code/LWO/LWOLoader.cpp @@ -49,14 +49,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER // internal headers -#include "LWOLoader.h" +#include "LWO/LWOLoader.h" +#include "PostProcessing/ProcessHelper.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include #include #include -#include "ProcessHelper.h" -#include "ConvertToLHProcess.h" #include #include + #include #include #include @@ -1326,6 +1328,7 @@ void LWOImporter::LoadLWO2File() bool skip = false; LE_NCONST uint8_t* const end = mFileBuffer + fileSize; + unsigned int iUnnamed = 0; while (true) { if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break; @@ -1337,7 +1340,6 @@ void LWOImporter::LoadLWO2File() break; } uint8_t* const next = mFileBuffer+head.length; - unsigned int iUnnamed = 0; if(!head.length) { mFileBuffer = next; diff --git a/code/LWOLoader.h b/code/LWO/LWOLoader.h similarity index 100% rename from code/LWOLoader.h rename to code/LWO/LWOLoader.h diff --git a/code/LWOMaterial.cpp b/code/LWO/LWOMaterial.cpp similarity index 100% rename from code/LWOMaterial.cpp rename to code/LWO/LWOMaterial.cpp diff --git a/code/LWSLoader.cpp b/code/LWS/LWSLoader.cpp similarity index 99% rename from code/LWSLoader.cpp rename to code/LWS/LWSLoader.cpp index d0811625c..b52cafa6d 100644 --- a/code/LWSLoader.cpp +++ b/code/LWS/LWSLoader.cpp @@ -48,19 +48,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_LWS_IMPORTER -#include "LWSLoader.h" +#include "LWS/LWSLoader.h" +#include "PostProcessing/ConvertToLHProcess.h" +#include "Common/Importer.h" + #include #include - #include #include #include -#include "ConvertToLHProcess.h" -#include "Importer.h" #include #include #include #include + #include using namespace Assimp; diff --git a/code/LWSLoader.h b/code/LWS/LWSLoader.h similarity index 99% rename from code/LWSLoader.h rename to code/LWS/LWSLoader.h index 3c24b59ea..eed0491f3 100644 --- a/code/LWSLoader.h +++ b/code/LWS/LWSLoader.h @@ -46,7 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_LWSLOADER_H_INCLUDED #define AI_LWSLOADER_H_INCLUDED -#include "LWOFileData.h" +#include "LWO/LWOFileData.h" + #include #include diff --git a/code/MD2FileData.h b/code/MD2/MD2FileData.h similarity index 100% rename from code/MD2FileData.h rename to code/MD2/MD2FileData.h diff --git a/code/MD2Loader.cpp b/code/MD2/MD2Loader.cpp similarity index 100% rename from code/MD2Loader.cpp rename to code/MD2/MD2Loader.cpp diff --git a/code/MD2Loader.h b/code/MD2/MD2Loader.h similarity index 100% rename from code/MD2Loader.h rename to code/MD2/MD2Loader.h diff --git a/code/MD2NormalTable.h b/code/MD2/MD2NormalTable.h similarity index 100% rename from code/MD2NormalTable.h rename to code/MD2/MD2NormalTable.h diff --git a/code/MD3FileData.h b/code/MD3/MD3FileData.h similarity index 100% rename from code/MD3FileData.h rename to code/MD3/MD3FileData.h diff --git a/code/MD3Loader.cpp b/code/MD3/MD3Loader.cpp similarity index 99% rename from code/MD3Loader.cpp rename to code/MD3/MD3Loader.cpp index cd58931f8..1e78b6e05 100644 --- a/code/MD3Loader.cpp +++ b/code/MD3/MD3Loader.cpp @@ -53,19 +53,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER -#include "MD3Loader.h" +#include "MD3/MD3Loader.h" +#include "Common/Importer.h" + #include #include #include #include -#include "Importer.h" #include -#include #include #include #include #include + #include +#include using namespace Assimp; diff --git a/code/MD3Loader.h b/code/MD3/MD3Loader.h similarity index 100% rename from code/MD3Loader.h rename to code/MD3/MD3Loader.h diff --git a/code/MD4FileData.h b/code/MD4/MD4FileData.h similarity index 100% rename from code/MD4FileData.h rename to code/MD4/MD4FileData.h diff --git a/code/MD5Loader.cpp b/code/MD5/MD5Loader.cpp similarity index 100% rename from code/MD5Loader.cpp rename to code/MD5/MD5Loader.cpp diff --git a/code/MD5Loader.h b/code/MD5/MD5Loader.h similarity index 100% rename from code/MD5Loader.h rename to code/MD5/MD5Loader.h diff --git a/code/MD5Parser.cpp b/code/MD5/MD5Parser.cpp similarity index 99% rename from code/MD5Parser.cpp rename to code/MD5/MD5Parser.cpp index 2770226a9..b955e9cbc 100644 --- a/code/MD5Parser.cpp +++ b/code/MD5/MD5Parser.cpp @@ -47,16 +47,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // internal headers -#include "MD5Loader.h" -#include "MaterialSystem.h" +#include "MD5/MD5Loader.h" +#include "Material/MaterialSystem.h" + #include #include #include #include #include - - using namespace Assimp; using namespace Assimp::MD5; diff --git a/code/MD5Parser.h b/code/MD5/MD5Parser.h similarity index 100% rename from code/MD5Parser.h rename to code/MD5/MD5Parser.h diff --git a/code/MDCFileData.h b/code/MDC/MDCFileData.h similarity index 100% rename from code/MDCFileData.h rename to code/MDC/MDCFileData.h diff --git a/code/MDCLoader.cpp b/code/MDC/MDCLoader.cpp similarity index 99% rename from code/MDCLoader.cpp rename to code/MDC/MDCLoader.cpp index 42947f123..084ec6024 100644 --- a/code/MDCLoader.cpp +++ b/code/MDC/MDCLoader.cpp @@ -47,16 +47,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_MDC_IMPORTER // internal headers -#include "MDCLoader.h" -#include "MD3FileData.h" -#include "MDCNormalTable.h" // shouldn't be included by other units +#include "MDC/MDCLoader.h" +#include "MD3/MD3FileData.h" +#include "MDC/MDCNormalTable.h" // shouldn't be included by other units + #include #include #include #include #include -#include +#include using namespace Assimp; using namespace Assimp::MDC; diff --git a/code/MDCLoader.h b/code/MDC/MDCLoader.h similarity index 100% rename from code/MDCLoader.h rename to code/MDC/MDCLoader.h diff --git a/code/MDCNormalTable.h b/code/MDC/MDCNormalTable.h similarity index 100% rename from code/MDCNormalTable.h rename to code/MDC/MDCNormalTable.h diff --git a/code/MDLDefaultColorMap.h b/code/MDL/MDLDefaultColorMap.h similarity index 100% rename from code/MDLDefaultColorMap.h rename to code/MDL/MDLDefaultColorMap.h diff --git a/code/MDLFileData.h b/code/MDL/MDLFileData.h similarity index 100% rename from code/MDLFileData.h rename to code/MDL/MDLFileData.h diff --git a/code/MDLLoader.cpp b/code/MDL/MDLLoader.cpp similarity index 99% rename from code/MDLLoader.cpp rename to code/MDL/MDLLoader.cpp index 256d79a2c..9ca36c079 100644 --- a/code/MDLLoader.cpp +++ b/code/MDL/MDLLoader.cpp @@ -50,11 +50,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER -#include "MDLLoader.h" +#include "MDL/MDLLoader.h" +#include "MDL/MDLDefaultColorMap.h" +#include "MD2/MD2FileData.h" + #include #include -#include "MDLDefaultColorMap.h" -#include "MD2FileData.h" #include #include #include diff --git a/code/MDLLoader.h b/code/MDL/MDLLoader.h similarity index 99% rename from code/MDLLoader.h rename to code/MDL/MDLLoader.h index 7009d5ba4..bbe945529 100644 --- a/code/MDLLoader.h +++ b/code/MDL/MDLLoader.h @@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include "MDLFileData.h" -#include "HalfLifeFileData.h" +#include "HMP/HalfLifeFileData.h" struct aiNode; struct aiTexture; diff --git a/code/MDLMaterialLoader.cpp b/code/MDL/MDLMaterialLoader.cpp similarity index 100% rename from code/MDLMaterialLoader.cpp rename to code/MDL/MDLMaterialLoader.cpp diff --git a/code/MMDCpp14.h b/code/MMD/MMDCpp14.h similarity index 100% rename from code/MMDCpp14.h rename to code/MMD/MMDCpp14.h diff --git a/code/MMDImporter.cpp b/code/MMD/MMDImporter.cpp similarity index 98% rename from code/MMDImporter.cpp rename to code/MMD/MMDImporter.cpp index 84b9e35a6..e7744e4cd 100644 --- a/code/MMDImporter.cpp +++ b/code/MMD/MMDImporter.cpp @@ -41,15 +41,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER -#include "MMDImporter.h" -#include "MMDPmdParser.h" -#include "MMDPmxParser.h" -#include "MMDVmdParser.h" -#include "ConvertToLHProcess.h" +#include "MMD/MMDImporter.h" +#include "MMD/MMDPmdParser.h" +#include "MMD/MMDPmxParser.h" +#include "MMD/MMDVmdParser.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include #include #include #include + #include #include #include diff --git a/code/MMDImporter.h b/code/MMD/MMDImporter.h similarity index 100% rename from code/MMDImporter.h rename to code/MMD/MMDImporter.h diff --git a/code/MMDPmdParser.h b/code/MMD/MMDPmdParser.h similarity index 100% rename from code/MMDPmdParser.h rename to code/MMD/MMDPmdParser.h diff --git a/code/MMDPmxParser.cpp b/code/MMD/MMDPmxParser.cpp similarity index 99% rename from code/MMDPmxParser.cpp rename to code/MMD/MMDPmxParser.cpp index 7425ceac2..80f0986dd 100644 --- a/code/MMDPmxParser.cpp +++ b/code/MMD/MMDPmxParser.cpp @@ -42,7 +42,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include "MMDPmxParser.h" #include -#include "../contrib/utf8cpp/source/utf8.h" +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include "../contrib/utf8cpp/source/utf8.h" +#endif #include namespace pmx diff --git a/code/MMDPmxParser.h b/code/MMD/MMDPmxParser.h similarity index 100% rename from code/MMDPmxParser.h rename to code/MMD/MMDPmxParser.h diff --git a/code/MMDVmdParser.h b/code/MMD/MMDVmdParser.h similarity index 100% rename from code/MMDVmdParser.h rename to code/MMD/MMDVmdParser.h diff --git a/code/MS3DLoader.cpp b/code/MS3D/MS3DLoader.cpp similarity index 100% rename from code/MS3DLoader.cpp rename to code/MS3D/MS3DLoader.cpp diff --git a/code/MS3DLoader.h b/code/MS3D/MS3DLoader.h similarity index 100% rename from code/MS3DLoader.h rename to code/MS3D/MS3DLoader.h diff --git a/code/MaterialSystem.cpp b/code/Material/MaterialSystem.cpp similarity index 98% rename from code/MaterialSystem.cpp rename to code/Material/MaterialSystem.cpp index 03d5a18a3..d0b39093b 100644 --- a/code/MaterialSystem.cpp +++ b/code/Material/MaterialSystem.cpp @@ -96,12 +96,12 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat, ai_real* pOut, unsigned int* pMax) { - ai_assert( pOut != NULL ); - ai_assert( pMat != NULL ); + ai_assert( pOut != nullptr ); + ai_assert( pMat != nullptr ); const aiMaterialProperty* prop; aiGetMaterialProperty(pMat,pKey,type,index, (const aiMaterialProperty**) &prop); - if (!prop) { + if ( nullptr == prop) { return AI_FAILURE; } @@ -112,9 +112,11 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat, if (pMax) { iWrite = std::min(*pMax,iWrite); ; } - for (unsigned int a = 0; a < iWrite;++a) { - pOut[a] = static_cast ( reinterpret_cast(prop->mData)[a] ); + + for (unsigned int a = 0; a < iWrite; ++a) { + pOut[ a ] = static_cast ( reinterpret_cast(prop->mData)[a] ); } + if (pMax) { *pMax = iWrite; } diff --git a/code/MaterialSystem.h b/code/Material/MaterialSystem.h similarity index 100% rename from code/MaterialSystem.h rename to code/Material/MaterialSystem.h diff --git a/code/NDOLoader.cpp b/code/NDO/NDOLoader.cpp similarity index 100% rename from code/NDOLoader.cpp rename to code/NDO/NDOLoader.cpp diff --git a/code/NDOLoader.h b/code/NDO/NDOLoader.h similarity index 100% rename from code/NDOLoader.h rename to code/NDO/NDOLoader.h diff --git a/code/NFFLoader.cpp b/code/NFF/NFFLoader.cpp similarity index 100% rename from code/NFFLoader.cpp rename to code/NFF/NFFLoader.cpp diff --git a/code/NFFLoader.h b/code/NFF/NFFLoader.h similarity index 100% rename from code/NFFLoader.h rename to code/NFF/NFFLoader.h diff --git a/code/OFFLoader.cpp b/code/OFF/OFFLoader.cpp similarity index 100% rename from code/OFFLoader.cpp rename to code/OFF/OFFLoader.cpp diff --git a/code/OFFLoader.h b/code/OFF/OFFLoader.h similarity index 100% rename from code/OFFLoader.h rename to code/OFF/OFFLoader.h diff --git a/code/ObjExporter.cpp b/code/Obj/ObjExporter.cpp similarity index 99% rename from code/ObjExporter.cpp rename to code/Obj/ObjExporter.cpp index 08cba43f7..0a0dbd62c 100644 --- a/code/ObjExporter.cpp +++ b/code/Obj/ObjExporter.cpp @@ -126,9 +126,9 @@ ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene, bool noMt // make sure that all formatting happens using the standard, C locale and not the user's current locale const std::locale& l = std::locale("C"); mOutput.imbue(l); - mOutput.precision(16); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); mOutputMat.imbue(l); - mOutputMat.precision(16); + mOutputMat.precision(ASSIMP_AI_REAL_TEXT_PRECISION); WriteGeometryFile(noMtl); if ( !noMtl ) { diff --git a/code/ObjExporter.h b/code/Obj/ObjExporter.h similarity index 100% rename from code/ObjExporter.h rename to code/Obj/ObjExporter.h diff --git a/code/ObjFileData.h b/code/Obj/ObjFileData.h similarity index 100% rename from code/ObjFileData.h rename to code/Obj/ObjFileData.h diff --git a/code/ObjFileImporter.cpp b/code/Obj/ObjFileImporter.cpp similarity index 100% rename from code/ObjFileImporter.cpp rename to code/Obj/ObjFileImporter.cpp diff --git a/code/ObjFileImporter.h b/code/Obj/ObjFileImporter.h similarity index 100% rename from code/ObjFileImporter.h rename to code/Obj/ObjFileImporter.h diff --git a/code/ObjFileMtlImporter.cpp b/code/Obj/ObjFileMtlImporter.cpp similarity index 100% rename from code/ObjFileMtlImporter.cpp rename to code/Obj/ObjFileMtlImporter.cpp diff --git a/code/ObjFileMtlImporter.h b/code/Obj/ObjFileMtlImporter.h similarity index 100% rename from code/ObjFileMtlImporter.h rename to code/Obj/ObjFileMtlImporter.h diff --git a/code/ObjFileParser.cpp b/code/Obj/ObjFileParser.cpp similarity index 100% rename from code/ObjFileParser.cpp rename to code/Obj/ObjFileParser.cpp diff --git a/code/ObjFileParser.h b/code/Obj/ObjFileParser.h similarity index 100% rename from code/ObjFileParser.h rename to code/Obj/ObjFileParser.h diff --git a/code/ObjTools.h b/code/Obj/ObjTools.h similarity index 100% rename from code/ObjTools.h rename to code/Obj/ObjTools.h diff --git a/code/OgreBinarySerializer.cpp b/code/Ogre/OgreBinarySerializer.cpp similarity index 99% rename from code/OgreBinarySerializer.cpp rename to code/Ogre/OgreBinarySerializer.cpp index b2326e244..589e69c7e 100644 --- a/code/OgreBinarySerializer.cpp +++ b/code/Ogre/OgreBinarySerializer.cpp @@ -864,6 +864,8 @@ bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *me } MemoryStreamReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef); + if (!reader) + return false; Skeleton *skeleton = new Skeleton(); OgreBinarySerializer serializer(reader.get(), OgreBinarySerializer::AM_Skeleton); diff --git a/code/OgreBinarySerializer.h b/code/Ogre/OgreBinarySerializer.h similarity index 100% rename from code/OgreBinarySerializer.h rename to code/Ogre/OgreBinarySerializer.h diff --git a/code/OgreImporter.cpp b/code/Ogre/OgreImporter.cpp similarity index 100% rename from code/OgreImporter.cpp rename to code/Ogre/OgreImporter.cpp diff --git a/code/OgreImporter.h b/code/Ogre/OgreImporter.h similarity index 100% rename from code/OgreImporter.h rename to code/Ogre/OgreImporter.h diff --git a/code/OgreMaterial.cpp b/code/Ogre/OgreMaterial.cpp similarity index 100% rename from code/OgreMaterial.cpp rename to code/Ogre/OgreMaterial.cpp diff --git a/code/OgreParsingUtils.h b/code/Ogre/OgreParsingUtils.h similarity index 100% rename from code/OgreParsingUtils.h rename to code/Ogre/OgreParsingUtils.h diff --git a/code/OgreStructs.cpp b/code/Ogre/OgreStructs.cpp similarity index 100% rename from code/OgreStructs.cpp rename to code/Ogre/OgreStructs.cpp diff --git a/code/OgreStructs.h b/code/Ogre/OgreStructs.h similarity index 100% rename from code/OgreStructs.h rename to code/Ogre/OgreStructs.h diff --git a/code/OgreXmlSerializer.cpp b/code/Ogre/OgreXmlSerializer.cpp similarity index 100% rename from code/OgreXmlSerializer.cpp rename to code/Ogre/OgreXmlSerializer.cpp diff --git a/code/OgreXmlSerializer.h b/code/Ogre/OgreXmlSerializer.h similarity index 100% rename from code/OgreXmlSerializer.h rename to code/Ogre/OgreXmlSerializer.h diff --git a/code/OpenGEXExporter.cpp b/code/OpenGEX/OpenGEXExporter.cpp similarity index 100% rename from code/OpenGEXExporter.cpp rename to code/OpenGEX/OpenGEXExporter.cpp diff --git a/code/OpenGEXExporter.h b/code/OpenGEX/OpenGEXExporter.h similarity index 100% rename from code/OpenGEXExporter.h rename to code/OpenGEX/OpenGEXExporter.h diff --git a/code/OpenGEXImporter.cpp b/code/OpenGEX/OpenGEXImporter.cpp similarity index 99% rename from code/OpenGEXImporter.cpp rename to code/OpenGEX/OpenGEXImporter.cpp index a7a143035..07d3efd5e 100644 --- a/code/OpenGEXImporter.cpp +++ b/code/OpenGEX/OpenGEXImporter.cpp @@ -41,10 +41,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER -#include "OpenGEXImporter.h" +#include "OpenGEX/OpenGEXImporter.h" +#include "PostProcessing/MakeVerboseFormat.h" + #include #include -#include "MakeVerboseFormat.h" #include #include @@ -212,7 +213,11 @@ static void propId2StdString( Property *prop, std::string &name, std::string &ke } if ( nullptr != prop->m_key ) { +#ifdef ASSIMP_USE_HUNTER + name = prop->m_key->m_text.m_buffer; +#else name = prop->m_key->m_buffer; +#endif if ( Value::ddl_string == prop->m_value->m_type ) { key = prop->m_value->getString(); } @@ -497,7 +502,11 @@ static void getRefNames( DDLNode *node, std::vector &names ) { for( size_t i = 0; i < ref->m_numRefs; i++ ) { Name *currentName( ref->m_referencedName[ i ] ); if( nullptr != currentName && nullptr != currentName->m_id ) { +#ifdef ASSIMP_USE_HUNTER + const std::string name( currentName->m_id->m_text.m_buffer ); +#else const std::string name( currentName->m_id->m_buffer ); +#endif if( !name.empty() ) { names.push_back( name ); } @@ -1038,7 +1047,11 @@ void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene * /*pS col.g = col4.g; col.b = col4.b; } +#ifdef ASSIMP_USE_HUNTER + const ColorType colType( getColorType( &prop->m_key->m_text ) ); +#else const ColorType colType( getColorType( prop->m_key ) ); +#endif if( DiffuseColor == colType ) { m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_DIFFUSE ); } else if( SpecularColor == colType ) { diff --git a/code/OpenGEXImporter.h b/code/OpenGEX/OpenGEXImporter.h similarity index 100% rename from code/OpenGEXImporter.h rename to code/OpenGEX/OpenGEXImporter.h diff --git a/code/OpenGEXStructs.h b/code/OpenGEX/OpenGEXStructs.h similarity index 100% rename from code/OpenGEXStructs.h rename to code/OpenGEX/OpenGEXStructs.h diff --git a/code/PlyExporter.cpp b/code/Ply/PlyExporter.cpp similarity index 99% rename from code/PlyExporter.cpp rename to code/Ply/PlyExporter.cpp index 4f9fa6c6f..5e21a88ac 100644 --- a/code/PlyExporter.cpp +++ b/code/Ply/PlyExporter.cpp @@ -111,7 +111,7 @@ PlyExporter::PlyExporter(const char* _filename, const aiScene* pScene, bool bina // make sure that all formatting happens using the standard, C locale and not the user's current locale const std::locale& l = std::locale("C"); mOutput.imbue(l); - mOutput.precision(16); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); unsigned int faces = 0u, vertices = 0u, components = 0u; for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { diff --git a/code/PlyExporter.h b/code/Ply/PlyExporter.h similarity index 100% rename from code/PlyExporter.h rename to code/Ply/PlyExporter.h diff --git a/code/PlyLoader.cpp b/code/Ply/PlyLoader.cpp similarity index 100% rename from code/PlyLoader.cpp rename to code/Ply/PlyLoader.cpp diff --git a/code/PlyLoader.h b/code/Ply/PlyLoader.h similarity index 100% rename from code/PlyLoader.h rename to code/Ply/PlyLoader.h diff --git a/code/PlyParser.cpp b/code/Ply/PlyParser.cpp similarity index 100% rename from code/PlyParser.cpp rename to code/Ply/PlyParser.cpp diff --git a/code/PlyParser.h b/code/Ply/PlyParser.h similarity index 100% rename from code/PlyParser.h rename to code/Ply/PlyParser.h diff --git a/code/CalcTangentsProcess.cpp b/code/PostProcessing/CalcTangentsProcess.cpp similarity index 100% rename from code/CalcTangentsProcess.cpp rename to code/PostProcessing/CalcTangentsProcess.cpp diff --git a/code/CalcTangentsProcess.h b/code/PostProcessing/CalcTangentsProcess.h similarity index 98% rename from code/CalcTangentsProcess.h rename to code/PostProcessing/CalcTangentsProcess.h index 18775abcc..3568a624f 100644 --- a/code/CalcTangentsProcess.h +++ b/code/PostProcessing/CalcTangentsProcess.h @@ -42,11 +42,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** @file Defines a post processing step to calculate tangents and - bitangents on all imported meshes.*/ + bi-tangents on all imported meshes.*/ #ifndef AI_CALCTANGENTSPROCESS_H_INC #define AI_CALCTANGENTSPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" struct aiMesh; diff --git a/code/ComputeUVMappingProcess.cpp b/code/PostProcessing/ComputeUVMappingProcess.cpp similarity index 100% rename from code/ComputeUVMappingProcess.cpp rename to code/PostProcessing/ComputeUVMappingProcess.cpp diff --git a/code/ComputeUVMappingProcess.h b/code/PostProcessing/ComputeUVMappingProcess.h similarity index 99% rename from code/ComputeUVMappingProcess.h rename to code/PostProcessing/ComputeUVMappingProcess.h index 24f6bb721..a6d36e06e 100644 --- a/code/ComputeUVMappingProcess.h +++ b/code/PostProcessing/ComputeUVMappingProcess.h @@ -45,7 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_COMPUTEUVMAPPING_H_INC #define AI_COMPUTEUVMAPPING_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include #include #include diff --git a/code/ConvertToLHProcess.cpp b/code/PostProcessing/ConvertToLHProcess.cpp similarity index 100% rename from code/ConvertToLHProcess.cpp rename to code/PostProcessing/ConvertToLHProcess.cpp diff --git a/code/ConvertToLHProcess.h b/code/PostProcessing/ConvertToLHProcess.h similarity index 99% rename from code/ConvertToLHProcess.h rename to code/PostProcessing/ConvertToLHProcess.h index 63351568d..f32b91fc3 100644 --- a/code/ConvertToLHProcess.h +++ b/code/PostProcessing/ConvertToLHProcess.h @@ -52,7 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define AI_CONVERTTOLHPROCESS_H_INC #include -#include "BaseProcess.h" + +#include "Common/BaseProcess.h" struct aiMesh; struct aiNodeAnim; diff --git a/code/DeboneProcess.cpp b/code/PostProcessing/DeboneProcess.cpp similarity index 100% rename from code/DeboneProcess.cpp rename to code/PostProcessing/DeboneProcess.cpp diff --git a/code/DeboneProcess.h b/code/PostProcessing/DeboneProcess.h similarity index 97% rename from code/DeboneProcess.h rename to code/PostProcessing/DeboneProcess.h index ba77aba70..8b64c2acc 100644 --- a/code/DeboneProcess.h +++ b/code/PostProcessing/DeboneProcess.h @@ -44,17 +44,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_DEBONEPROCESS_H_INC #define AI_DEBONEPROCESS_H_INC -#include -#include -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include #include +#include +#include + +#// Forward declarations class DeboneTest; -namespace Assimp -{ +namespace Assimp { #if (!defined AI_DEBONE_THRESHOLD) # define AI_DEBONE_THRESHOLD 1.0f @@ -66,14 +67,11 @@ namespace Assimp * the bone are split from the mesh. The split off (new) mesh is boneless. At any * point in time, bones without affect upon a given mesh are to be removed. */ -class DeboneProcess : public BaseProcess -{ +class DeboneProcess : public BaseProcess { public: - DeboneProcess(); ~DeboneProcess(); -public: // ------------------------------------------------------------------- /** Returns whether the processing step is present in the given flag. * @param pFlags The processing flags the importer was called with. @@ -91,7 +89,6 @@ public: void SetupProperties(const Importer* pImp); protected: - // ------------------------------------------------------------------- /** Executes the post processing step on the given imported data. * At the moment a process is not supposed to fail. diff --git a/code/DropFaceNormalsProcess.cpp b/code/PostProcessing/DropFaceNormalsProcess.cpp similarity index 100% rename from code/DropFaceNormalsProcess.cpp rename to code/PostProcessing/DropFaceNormalsProcess.cpp diff --git a/code/DropFaceNormalsProcess.h b/code/PostProcessing/DropFaceNormalsProcess.h similarity index 98% rename from code/DropFaceNormalsProcess.h rename to code/PostProcessing/DropFaceNormalsProcess.h index 0d116663b..c710c5a5e 100644 --- a/code/DropFaceNormalsProcess.h +++ b/code/PostProcessing/DropFaceNormalsProcess.h @@ -44,23 +44,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_DROPFACENORMALPROCESS_H_INC #define AI_DROPFACENORMALPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include -namespace Assimp -{ +namespace Assimp { // --------------------------------------------------------------------------- /** The DropFaceNormalsProcess computes face normals for all faces of all meshes */ -class ASSIMP_API_WINONLY DropFaceNormalsProcess : public BaseProcess -{ +class ASSIMP_API_WINONLY DropFaceNormalsProcess : public BaseProcess { public: - DropFaceNormalsProcess(); ~DropFaceNormalsProcess(); -public: // ------------------------------------------------------------------- /** Returns whether the processing step is present in the given flag field. * @param pFlags The processing flags the importer was called with. A bitwise diff --git a/code/EmbedTexturesProcess.cpp b/code/PostProcessing/EmbedTexturesProcess.cpp similarity index 100% rename from code/EmbedTexturesProcess.cpp rename to code/PostProcessing/EmbedTexturesProcess.cpp diff --git a/code/EmbedTexturesProcess.h b/code/PostProcessing/EmbedTexturesProcess.h similarity index 98% rename from code/EmbedTexturesProcess.h rename to code/PostProcessing/EmbedTexturesProcess.h index cdf40bef7..3c4b2eab4 100644 --- a/code/EmbedTexturesProcess.h +++ b/code/PostProcessing/EmbedTexturesProcess.h @@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #pragma once -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include diff --git a/code/FindDegenerates.cpp b/code/PostProcessing/FindDegenerates.cpp similarity index 99% rename from code/FindDegenerates.cpp rename to code/PostProcessing/FindDegenerates.cpp index 365f5d744..50fac46db 100644 --- a/code/FindDegenerates.cpp +++ b/code/PostProcessing/FindDegenerates.cpp @@ -228,6 +228,7 @@ bool FindDegeneratesProcess::ExecuteOnMesh( aiMesh* mesh) { if ( area < 1e-6 ) { if ( mConfigRemoveDegenerates ) { remove_me[ a ] = true; + ++deg; goto evil_jump_outside; } diff --git a/code/FindDegenerates.h b/code/PostProcessing/FindDegenerates.h similarity index 99% rename from code/FindDegenerates.h rename to code/PostProcessing/FindDegenerates.h index 880f5f16a..7a15e77cf 100644 --- a/code/FindDegenerates.h +++ b/code/PostProcessing/FindDegenerates.h @@ -45,7 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_FINDDEGENERATESPROCESS_H_INC #define AI_FINDDEGENERATESPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include class FindDegeneratesProcessTest; diff --git a/code/FindInstancesProcess.cpp b/code/PostProcessing/FindInstancesProcess.cpp similarity index 97% rename from code/FindInstancesProcess.cpp rename to code/PostProcessing/FindInstancesProcess.cpp index be1138116..64907458a 100644 --- a/code/FindInstancesProcess.cpp +++ b/code/PostProcessing/FindInstancesProcess.cpp @@ -137,6 +137,11 @@ void FindInstancesProcess::Execute( aiScene* pScene) aiMesh* inst = pScene->mMeshes[i]; hashes[i] = GetMeshHash(inst); + // Find an appropriate epsilon + // to compare position differences against + float epsilon = ComputePositionEpsilon(inst); + epsilon *= epsilon; + for (int a = i-1; a >= 0; --a) { if (hashes[i] == hashes[a]) { @@ -154,12 +159,7 @@ void FindInstancesProcess::Execute( aiScene* pScene) orig->mPrimitiveTypes != inst->mPrimitiveTypes) continue; - // up to now the meshes are equal. find an appropriate - // epsilon to compare position differences against - float epsilon = ComputePositionEpsilon(inst); - epsilon *= epsilon; - - // now compare vertex positions, normals, + // up to now the meshes are equal. Now compare vertex positions, normals, // tangents and bitangents using this epsilon. if (orig->HasPositions()) { if(!CompareArrays(orig->mVertices,inst->mVertices,orig->mNumVertices,epsilon)) diff --git a/code/FindInstancesProcess.h b/code/PostProcessing/FindInstancesProcess.h similarity index 98% rename from code/FindInstancesProcess.h rename to code/PostProcessing/FindInstancesProcess.h index ab4a371c7..64b838d7c 100644 --- a/code/FindInstancesProcess.h +++ b/code/PostProcessing/FindInstancesProcess.h @@ -46,8 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_FINDINSTANCES_H_INC #define AI_FINDINSTANCES_H_INC -#include "BaseProcess.h" -#include "ProcessHelper.h" +#include "Common/BaseProcess.h" +#include "PostProcessing/ProcessHelper.h" class FindInstancesProcessTest; namespace Assimp { diff --git a/code/FindInvalidDataProcess.cpp b/code/PostProcessing/FindInvalidDataProcess.cpp similarity index 100% rename from code/FindInvalidDataProcess.cpp rename to code/PostProcessing/FindInvalidDataProcess.cpp diff --git a/code/FindInvalidDataProcess.h b/code/PostProcessing/FindInvalidDataProcess.h similarity index 99% rename from code/FindInvalidDataProcess.h rename to code/PostProcessing/FindInvalidDataProcess.h index 8504fb7b1..ce7375f34 100644 --- a/code/FindInvalidDataProcess.h +++ b/code/PostProcessing/FindInvalidDataProcess.h @@ -46,7 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_FINDINVALIDDATA_H_INC #define AI_FINDINVALIDDATA_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include #include diff --git a/code/FixNormalsStep.cpp b/code/PostProcessing/FixNormalsStep.cpp similarity index 100% rename from code/FixNormalsStep.cpp rename to code/PostProcessing/FixNormalsStep.cpp diff --git a/code/FixNormalsStep.h b/code/PostProcessing/FixNormalsStep.h similarity index 99% rename from code/FixNormalsStep.h rename to code/PostProcessing/FixNormalsStep.h index 6be27faef..f60ce596a 100644 --- a/code/FixNormalsStep.h +++ b/code/PostProcessing/FixNormalsStep.h @@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_FIXNORMALSPROCESS_H_INC #define AI_FIXNORMALSPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" struct aiMesh; diff --git a/code/PostProcessing/GenBoundingBoxesProcess.cpp b/code/PostProcessing/GenBoundingBoxesProcess.cpp new file mode 100644 index 000000000..c013454fc --- /dev/null +++ b/code/PostProcessing/GenBoundingBoxesProcess.cpp @@ -0,0 +1,115 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2019, assimp team + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the following +conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------- +*/ + +#ifndef ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS + +#include "PostProcessing/GenBoundingBoxesProcess.h" + +#include +#include + +namespace Assimp { + +GenBoundingBoxesProcess::GenBoundingBoxesProcess() +: BaseProcess() { + +} + +GenBoundingBoxesProcess::~GenBoundingBoxesProcess() { + // empty +} + +bool GenBoundingBoxesProcess::IsActive(unsigned int pFlags) const { + return 0 != ( pFlags & aiProcess_GenBoundingBoxes ); +} + +void checkMesh(aiMesh* mesh, aiVector3D& min, aiVector3D& max) { + ai_assert(nullptr != mesh); + + if (0 == mesh->mNumVertices) { + return; + } + + for (unsigned int i = 0; i < mesh->mNumVertices; ++i) { + const aiVector3D &pos = mesh->mVertices[i]; + if (pos.x < min.x) { + min.x = pos.x; + } + if (pos.y < min.y) { + min.y = pos.y; + } + if (pos.z < min.z) { + min.z = pos.z; + } + + if (pos.x > max.x) { + max.x = pos.x; + } + if (pos.y > max.y) { + max.y = pos.y; + } + if (pos.z > max.z) { + max.z = pos.z; + } + } +} + +void GenBoundingBoxesProcess::Execute(aiScene* pScene) { + if (nullptr == pScene) { + return; + } + + for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { + aiMesh* mesh = pScene->mMeshes[i]; + if (nullptr == mesh) { + continue; + } + + aiVector3D min(999999, 999999, 999999), max(-999999, -999999, -999999); + checkMesh(mesh, min, max); + mesh->mAABB.mMin = min; + mesh->mAABB.mMax = max; + } +} + +} // Namespace Assimp + +#endif // ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS diff --git a/code/PostProcessing/GenBoundingBoxesProcess.h b/code/PostProcessing/GenBoundingBoxesProcess.h new file mode 100644 index 000000000..4b43c82a4 --- /dev/null +++ b/code/PostProcessing/GenBoundingBoxesProcess.h @@ -0,0 +1,76 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2019, assimp team + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the following +conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------- +*/ + +/** @file Defines a post-processing step to generate Axis-aligned bounding + * volumes for all meshes. + */ + +#pragma once + +#ifndef AI_GENBOUNDINGBOXESPROCESS_H_INC +#define AI_GENBOUNDINGBOXESPROCESS_H_INC + +#ifndef ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS + +#include "Common/BaseProcess.h" + +namespace Assimp { + +/** Post-processing process to find axis-aligned bounding volumes for amm meshes + * used in a scene + */ +class ASSIMP_API GenBoundingBoxesProcess : public BaseProcess { +public: + /// The class constructor. + GenBoundingBoxesProcess(); + /// The class destructor. + ~GenBoundingBoxesProcess(); + /// Will return true, if aiProcess_GenBoundingBoxes is defined. + bool IsActive(unsigned int pFlags) const override; + /// The execution callback. + void Execute(aiScene* pScene) override; +}; + +} // Namespace Assimp + +#endif // #ifndef ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS + +#endif // AI_GENBOUNDINGBOXESPROCESS_H_INC diff --git a/code/GenFaceNormalsProcess.cpp b/code/PostProcessing/GenFaceNormalsProcess.cpp similarity index 100% rename from code/GenFaceNormalsProcess.cpp rename to code/PostProcessing/GenFaceNormalsProcess.cpp diff --git a/code/GenFaceNormalsProcess.h b/code/PostProcessing/GenFaceNormalsProcess.h similarity index 98% rename from code/GenFaceNormalsProcess.h rename to code/PostProcessing/GenFaceNormalsProcess.h index c80ec9fdd..c641fd635 100644 --- a/code/GenFaceNormalsProcess.h +++ b/code/PostProcessing/GenFaceNormalsProcess.h @@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_GENFACENORMALPROCESS_H_INC #define AI_GENFACENORMALPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include namespace Assimp diff --git a/code/GenVertexNormalsProcess.cpp b/code/PostProcessing/GenVertexNormalsProcess.cpp similarity index 100% rename from code/GenVertexNormalsProcess.cpp rename to code/PostProcessing/GenVertexNormalsProcess.cpp diff --git a/code/GenVertexNormalsProcess.h b/code/PostProcessing/GenVertexNormalsProcess.h similarity index 94% rename from code/GenVertexNormalsProcess.h rename to code/PostProcessing/GenVertexNormalsProcess.h index 9142ad26f..2ceee17e8 100644 --- a/code/GenVertexNormalsProcess.h +++ b/code/PostProcessing/GenVertexNormalsProcess.h @@ -45,24 +45,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_GENVERTEXNORMALPROCESS_H_INC #define AI_GENVERTEXNORMALPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/assbin_chunks.h" +#include "Common/BaseProcess.h" + #include +// Forward declarations class GenNormalsTest; namespace Assimp { // --------------------------------------------------------------------------- -/** The GenFaceNormalsProcess computes vertex normals for all vertizes +/** The GenFaceNormalsProcess computes vertex normals for all vertices */ -class ASSIMP_API GenVertexNormalsProcess : public BaseProcess -{ +class ASSIMP_API GenVertexNormalsProcess : public BaseProcess { public: - GenVertexNormalsProcess(); ~GenVertexNormalsProcess(); -public: // ------------------------------------------------------------------- /** Returns whether the processing step is present in the given flag. * @param pFlags The processing flags the importer was called with. @@ -88,13 +88,10 @@ public: // setter for configMaxAngle - inline void SetMaxSmoothAngle(ai_real f) - { + inline void SetMaxSmoothAngle(ai_real f) { configMaxAngle =f; } -public: - // ------------------------------------------------------------------- /** Computes normals for a specific mesh * @param pcMesh Mesh @@ -104,7 +101,6 @@ public: bool GenMeshVertexNormals (aiMesh* pcMesh, unsigned int meshIndex); private: - /** Configuration option: maximum smoothing angle, in radians*/ ai_real configMaxAngle; mutable bool force_ = false; diff --git a/code/ImproveCacheLocality.cpp b/code/PostProcessing/ImproveCacheLocality.cpp similarity index 90% rename from code/ImproveCacheLocality.cpp rename to code/PostProcessing/ImproveCacheLocality.cpp index ace9d95ff..d0a016fa4 100644 --- a/code/ImproveCacheLocality.cpp +++ b/code/PostProcessing/ImproveCacheLocality.cpp @@ -45,14 +45,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
* The algorithm is roughly basing on this paper: * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf - * .. although overdraw rduction isn't implemented yet ... + * .. although overdraw reduction isn't implemented yet ... */ - - // internal headers -#include "ImproveCacheLocality.h" -#include "VertexTriangleAdjacency.h" +#include "PostProcessing/ImproveCacheLocality.h" +#include "Common/VertexTriangleAdjacency.h" + #include #include #include @@ -64,36 +63,33 @@ using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer -ImproveCacheLocalityProcess::ImproveCacheLocalityProcess() { - configCacheDepth = PP_ICL_PTCACHE_SIZE; +ImproveCacheLocalityProcess::ImproveCacheLocalityProcess() +: mConfigCacheDepth(PP_ICL_PTCACHE_SIZE) { + // empty } // ------------------------------------------------------------------------------------------------ // Destructor, private as well -ImproveCacheLocalityProcess::~ImproveCacheLocalityProcess() -{ +ImproveCacheLocalityProcess::~ImproveCacheLocalityProcess() { // nothing to do here } // ------------------------------------------------------------------------------------------------ // Returns whether the processing step is present in the given flag field. -bool ImproveCacheLocalityProcess::IsActive( unsigned int pFlags) const -{ +bool ImproveCacheLocalityProcess::IsActive( unsigned int pFlags) const { return (pFlags & aiProcess_ImproveCacheLocality) != 0; } // ------------------------------------------------------------------------------------------------ // Setup configuration -void ImproveCacheLocalityProcess::SetupProperties(const Importer* pImp) -{ +void ImproveCacheLocalityProcess::SetupProperties(const Importer* pImp) { // AI_CONFIG_PP_ICL_PTCACHE_SIZE controls the target cache size for the optimizer - configCacheDepth = pImp->GetPropertyInteger(AI_CONFIG_PP_ICL_PTCACHE_SIZE,PP_ICL_PTCACHE_SIZE); + mConfigCacheDepth = pImp->GetPropertyInteger(AI_CONFIG_PP_ICL_PTCACHE_SIZE,PP_ICL_PTCACHE_SIZE); } // ------------------------------------------------------------------------------------------------ // Executes the post processing step on the given imported data. -void ImproveCacheLocalityProcess::Execute( aiScene* pScene) -{ +void ImproveCacheLocalityProcess::Execute( aiScene* pScene) { if (!pScene->mNumMeshes) { ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess skipped; there are no meshes"); return; @@ -103,7 +99,7 @@ void ImproveCacheLocalityProcess::Execute( aiScene* pScene) float out = 0.f; unsigned int numf = 0, numm = 0; - for( unsigned int a = 0; a < pScene->mNumMeshes; a++){ + for( unsigned int a = 0; a < pScene->mNumMeshes; ++a ){ const float res = ProcessMesh( pScene->mMeshes[a],a); if (res) { numf += pScene->mMeshes[a]->mNumFaces; @@ -121,44 +117,41 @@ void ImproveCacheLocalityProcess::Execute( aiScene* pScene) // ------------------------------------------------------------------------------------------------ // Improves the cache coherency of a specific mesh -float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshNum) -{ +ai_real ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshNum) { // TODO: rewrite this to use std::vector or boost::shared_array - ai_assert(NULL != pMesh); + ai_assert(nullptr != pMesh); // Check whether the input data is valid // - there must be vertices and faces // - all faces must be triangulated or we can't operate on them if (!pMesh->HasFaces() || !pMesh->HasPositions()) - return 0.f; + return static_cast(0.f); if (pMesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE) { ASSIMP_LOG_ERROR("This algorithm works on triangle meshes only"); - return 0.f; + return static_cast(0.f); } - if(pMesh->mNumVertices <= configCacheDepth) { - return 0.f; + if(pMesh->mNumVertices <= mConfigCacheDepth) { + return static_cast(0.f); } - float fACMR = 3.f; + ai_real fACMR = 3.f; const aiFace* const pcEnd = pMesh->mFaces+pMesh->mNumFaces; // Input ACMR is for logging purposes only if (!DefaultLogger::isNullLogger()) { - unsigned int* piFIFOStack = new unsigned int[configCacheDepth]; - memset(piFIFOStack,0xff,configCacheDepth*sizeof(unsigned int)); + unsigned int* piFIFOStack = new unsigned int[mConfigCacheDepth]; + memset(piFIFOStack,0xff,mConfigCacheDepth*sizeof(unsigned int)); unsigned int* piCur = piFIFOStack; - const unsigned int* const piCurEnd = piFIFOStack + configCacheDepth; + const unsigned int* const piCurEnd = piFIFOStack + mConfigCacheDepth; // count the number of cache misses unsigned int iCacheMisses = 0; for (const aiFace* pcFace = pMesh->mFaces;pcFace != pcEnd;++pcFace) { - for (unsigned int qq = 0; qq < 3;++qq) { bool bInCache = false; - for (unsigned int* pp = piFIFOStack;pp < piCurEnd;++pp) { if (*pp == pcFace->mIndices[qq]) { // the vertex is in cache @@ -176,7 +169,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh } } delete[] piFIFOStack; - fACMR = (float)iCacheMisses / pMesh->mNumFaces; + fACMR = (ai_real) iCacheMisses / pMesh->mNumFaces; if (3.0 == fACMR) { char szBuff[128]; // should be sufficiently large in every case @@ -185,7 +178,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh // smaller than 3.0 ... ai_snprintf(szBuff,128,"Mesh %u: Not suitable for vcache optimization",meshNum); ASSIMP_LOG_WARN(szBuff); - return 0.f; + return static_cast(0.f); } } @@ -258,7 +251,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh int ivdx = 0; int ics = 1; - int iStampCnt = configCacheDepth+1; + int iStampCnt = mConfigCacheDepth+1; while (ivdx >= 0) { unsigned int icnt = piNumTriPtrNoModify[ivdx]; @@ -294,7 +287,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh *piCSIter++ = dp; // if the vertex is not yet in cache, set its cache count - if (iStampCnt-piCachingStamps[dp] > configCacheDepth) { + if (iStampCnt-piCachingStamps[dp] > mConfigCacheDepth) { piCachingStamps[dp] = iStampCnt++; ++iCacheMisses; } @@ -319,7 +312,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh // will the vertex be in cache, even after fanning occurs? unsigned int tmp; - if ((tmp = iStampCnt-piCachingStamps[dp]) + 2*piNumTriPtr[dp] <= configCacheDepth) { + if ((tmp = iStampCnt-piCachingStamps[dp]) + 2*piNumTriPtr[dp] <= mConfigCacheDepth) { priority = tmp; } @@ -356,7 +349,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh } } } - float fACMR2 = 0.0f; + ai_real fACMR2 = 0.0f; if (!DefaultLogger::isNullLogger()) { fACMR2 = (float)iCacheMisses / pMesh->mNumFaces; diff --git a/code/ImproveCacheLocality.h b/code/PostProcessing/ImproveCacheLocality.h similarity index 96% rename from code/ImproveCacheLocality.h rename to code/PostProcessing/ImproveCacheLocality.h index 1b29ee0d6..de25ecd9f 100644 --- a/code/ImproveCacheLocality.h +++ b/code/PostProcessing/ImproveCacheLocality.h @@ -45,7 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_IMPROVECACHELOCALITY_H_INC #define AI_IMPROVECACHELOCALITY_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include struct aiMesh; @@ -87,12 +88,12 @@ protected: * @param pMesh The mesh to process. * @param meshNum Index of the mesh to process */ - float ProcessMesh( aiMesh* pMesh, unsigned int meshNum); + ai_real ProcessMesh( aiMesh* pMesh, unsigned int meshNum); private: //! Configuration parameter: specifies the size of the cache to //! optimize the vertex data for. - unsigned int configCacheDepth; + unsigned int mConfigCacheDepth; }; } // end of namespace Assimp diff --git a/code/JoinVerticesProcess.cpp b/code/PostProcessing/JoinVerticesProcess.cpp similarity index 100% rename from code/JoinVerticesProcess.cpp rename to code/PostProcessing/JoinVerticesProcess.cpp diff --git a/code/JoinVerticesProcess.h b/code/PostProcessing/JoinVerticesProcess.h similarity index 97% rename from code/JoinVerticesProcess.h rename to code/PostProcessing/JoinVerticesProcess.h index 66fa362de..e017ae62d 100644 --- a/code/JoinVerticesProcess.h +++ b/code/PostProcessing/JoinVerticesProcess.h @@ -45,7 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_JOINVERTICESPROCESS_H_INC #define AI_JOINVERTICESPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include struct aiMesh; @@ -61,13 +62,11 @@ namespace Assimp * erases all but one of the copies. This usually reduces the number of vertices * in a mesh by a serious amount and is the standard form to render a mesh. */ -class ASSIMP_API JoinVerticesProcess : public BaseProcess -{ +class ASSIMP_API JoinVerticesProcess : public BaseProcess { public: JoinVerticesProcess(); ~JoinVerticesProcess(); -public: // ------------------------------------------------------------------- /** Returns whether the processing step is present in the given flag field. * @param pFlags The processing flags the importer was called with. A bitwise @@ -83,15 +82,12 @@ public: */ void Execute( aiScene* pScene); -public: // ------------------------------------------------------------------- /** Unites identical vertices in the given mesh. * @param pMesh The mesh to process. * @param meshIndex Index of the mesh to process */ int ProcessMesh( aiMesh* pMesh, unsigned int meshIndex); - -private: }; } // end of namespace Assimp diff --git a/code/LimitBoneWeightsProcess.cpp b/code/PostProcessing/LimitBoneWeightsProcess.cpp similarity index 100% rename from code/LimitBoneWeightsProcess.cpp rename to code/PostProcessing/LimitBoneWeightsProcess.cpp diff --git a/code/LimitBoneWeightsProcess.h b/code/PostProcessing/LimitBoneWeightsProcess.h similarity index 93% rename from code/LimitBoneWeightsProcess.h rename to code/PostProcessing/LimitBoneWeightsProcess.h index 3602fd8ed..73c2a68d5 100644 --- a/code/LimitBoneWeightsProcess.h +++ b/code/PostProcessing/LimitBoneWeightsProcess.h @@ -44,14 +44,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_LIMITBONEWEIGHTSPROCESS_H_INC #define AI_LIMITBONEWEIGHTSPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" +// Forward declarations struct aiMesh; class LimitBoneWeightsTest; -namespace Assimp -{ +namespace Assimp { // NOTE: If you change these limits, don't forget to change the // corresponding values in all Assimp ports @@ -72,14 +72,11 @@ namespace Assimp * The other weights on this bone are then renormalized to assure the sum weight * to be 1. */ -class ASSIMP_API LimitBoneWeightsProcess : public BaseProcess -{ +class ASSIMP_API LimitBoneWeightsProcess : public BaseProcess { public: - LimitBoneWeightsProcess(); ~LimitBoneWeightsProcess(); -public: // ------------------------------------------------------------------- /** Returns whether the processing step is present in the given flag. * @param pFlags The processing flags the importer was called with. @@ -96,8 +93,6 @@ public: */ void SetupProperties(const Importer* pImp); -public: - // ------------------------------------------------------------------- /** Limits the bone weight count for all vertices in the given mesh. * @param pMesh The mesh to process. @@ -111,34 +106,29 @@ public: */ void Execute( aiScene* pScene); - -public: - // ------------------------------------------------------------------- /** Describes a bone weight on a vertex */ - struct Weight - { + struct Weight { unsigned int mBone; ///< Index of the bone float mWeight; ///< Weight of that bone on this vertex Weight() AI_NO_EXCEPT : mBone(0) - , mWeight(0.0f) - { } + , mWeight(0.0f) { + // empty + } Weight( unsigned int pBone, float pWeight) - { - mBone = pBone; - mWeight = pWeight; + : mBone(pBone) + , mWeight(pWeight) { + // empty } /** Comparison operator to sort bone weights by descending weight */ - bool operator < (const Weight& pWeight) const - { + bool operator < (const Weight& pWeight) const { return mWeight > pWeight.mWeight; } }; -public: /** Maximum number of bones influencing any single vertex. */ unsigned int mMaxWeights; }; diff --git a/code/MakeVerboseFormat.cpp b/code/PostProcessing/MakeVerboseFormat.cpp similarity index 100% rename from code/MakeVerboseFormat.cpp rename to code/PostProcessing/MakeVerboseFormat.cpp diff --git a/code/MakeVerboseFormat.h b/code/PostProcessing/MakeVerboseFormat.h similarity index 99% rename from code/MakeVerboseFormat.h rename to code/PostProcessing/MakeVerboseFormat.h index d12db63ae..1adf8e2f6 100644 --- a/code/MakeVerboseFormat.h +++ b/code/PostProcessing/MakeVerboseFormat.h @@ -46,7 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_MAKEVERBOSEFORMAT_H_INC #define AI_MAKEVERBOSEFORMAT_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + struct aiMesh; namespace Assimp { diff --git a/code/OptimizeGraph.cpp b/code/PostProcessing/OptimizeGraph.cpp similarity index 99% rename from code/OptimizeGraph.cpp rename to code/PostProcessing/OptimizeGraph.cpp index add9ab79e..5db51f58b 100644 --- a/code/OptimizeGraph.cpp +++ b/code/PostProcessing/OptimizeGraph.cpp @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2019, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms, diff --git a/code/OptimizeGraph.h b/code/PostProcessing/OptimizeGraph.h similarity index 93% rename from code/OptimizeGraph.h rename to code/PostProcessing/OptimizeGraph.h index e5bbed767..82cc5db3f 100644 --- a/code/OptimizeGraph.h +++ b/code/PostProcessing/OptimizeGraph.h @@ -46,13 +46,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_OPTIMIZEGRAPHPROCESS_H_INC #define AI_OPTIMIZEGRAPHPROCESS_H_INC -#include "BaseProcess.h" -#include "ProcessHelper.h" +#include "Common/BaseProcess.h" +#include "PostProcessing/ProcessHelper.h" + #include + #include +// Forward declarations struct aiMesh; + class OptimizeGraphProcessTest; + namespace Assimp { // ----------------------------------------------------------------------------- @@ -64,14 +69,11 @@ namespace Assimp { * @see aiProcess_OptimizeGraph for a detailed description of the * algorithm being applied. */ -class OptimizeGraphProcess : public BaseProcess -{ +class OptimizeGraphProcess : public BaseProcess { public: - OptimizeGraphProcess(); ~OptimizeGraphProcess(); -public: // ------------------------------------------------------------------- bool IsActive( unsigned int pFlags) const; @@ -81,14 +83,12 @@ public: // ------------------------------------------------------------------- void SetupProperties(const Importer* pImp); - // ------------------------------------------------------------------- /** @brief Add a list of node names to be locked and not modified. * @param in List of nodes. See #AI_CONFIG_PP_OG_EXCLUDE_LIST for * format explanations. */ - inline void AddLockedNodeList(std::string& in) - { + inline void AddLockedNodeList(std::string& in) { ConvertListToStrings (in,locked_nodes); } @@ -96,8 +96,7 @@ public: /** @brief Add another node to be locked and not modified. * @param name Name to be locked */ - inline void AddLockedNode(std::string& name) - { + inline void AddLockedNode(std::string& name) { locked_nodes.push_back(name); } @@ -105,25 +104,21 @@ public: /** @brief Remove a node from the list of locked nodes. * @param name Name to be unlocked */ - inline void RemoveLockedNode(std::string& name) - { + inline void RemoveLockedNode(std::string& name) { locked_nodes.remove(name); } protected: - void CollectNewChildren(aiNode* nd, std::list& nodes); void FindInstancedMeshes (aiNode* pNode); private: - #ifdef AI_OG_USE_HASHING typedef std::set LockedSetType; #else typedef std::set LockedSetType; #endif - //! Scene we're working with aiScene* mScene; diff --git a/code/OptimizeMeshes.cpp b/code/PostProcessing/OptimizeMeshes.cpp similarity index 100% rename from code/OptimizeMeshes.cpp rename to code/PostProcessing/OptimizeMeshes.cpp diff --git a/code/OptimizeMeshes.h b/code/PostProcessing/OptimizeMeshes.h similarity index 97% rename from code/OptimizeMeshes.h rename to code/PostProcessing/OptimizeMeshes.h index 9f46f349b..dec4ab52d 100644 --- a/code/OptimizeMeshes.h +++ b/code/PostProcessing/OptimizeMeshes.h @@ -46,8 +46,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_OPTIMIZEMESHESPROCESS_H_INC #define AI_OPTIMIZEMESHESPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include + #include struct aiMesh; @@ -64,16 +66,14 @@ namespace Assimp { * * @note Instanced meshes are currently not processed. */ -class OptimizeMeshesProcess : public BaseProcess -{ +class OptimizeMeshesProcess : public BaseProcess { public: /// @brief The class constructor. OptimizeMeshesProcess(); - /// @brief The class destcructor, + /// @brief The class destructor. ~OptimizeMeshesProcess(); - /** @brief Internal utility to store additional mesh info */ struct MeshInfo { diff --git a/code/PretransformVertices.cpp b/code/PostProcessing/PretransformVertices.cpp similarity index 100% rename from code/PretransformVertices.cpp rename to code/PostProcessing/PretransformVertices.cpp diff --git a/code/PretransformVertices.h b/code/PostProcessing/PretransformVertices.h similarity index 97% rename from code/PretransformVertices.h rename to code/PostProcessing/PretransformVertices.h index b7329af13..b2982951e 100644 --- a/code/PretransformVertices.h +++ b/code/PostProcessing/PretransformVertices.h @@ -47,13 +47,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_PRETRANSFORMVERTICES_H_INC #define AI_PRETRANSFORMVERTICES_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include + #include #include +// Forward declarations struct aiNode; + class PretransformVerticesTest; + namespace Assimp { // --------------------------------------------------------------------------- @@ -80,10 +85,10 @@ public: // ------------------------------------------------------------------- /** @brief Toggle the 'keep hierarchy' option - * @param d hm ... difficult to guess what this means, hu!? + * @param keep true for keep configuration. */ - void KeepHierarchy(bool d) { - configKeepHierarchy = d; + void KeepHierarchy(bool keep) { + configKeepHierarchy = keep; } // ------------------------------------------------------------------- @@ -148,8 +153,6 @@ private: // Build reference counters for all meshes void BuildMeshRefCountArray(aiNode* nd, unsigned int * refs); - - //! Configuration option: keep scene hierarchy as long as possible bool configKeepHierarchy; bool configNormalize; diff --git a/code/ProcessHelper.cpp b/code/PostProcessing/ProcessHelper.cpp similarity index 100% rename from code/ProcessHelper.cpp rename to code/PostProcessing/ProcessHelper.cpp diff --git a/code/ProcessHelper.h b/code/PostProcessing/ProcessHelper.h similarity index 99% rename from code/ProcessHelper.h rename to code/PostProcessing/ProcessHelper.h index c59f3217b..0afcc4142 100644 --- a/code/ProcessHelper.h +++ b/code/PostProcessing/ProcessHelper.h @@ -51,7 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include #include diff --git a/code/RemoveRedundantMaterials.cpp b/code/PostProcessing/RemoveRedundantMaterials.cpp similarity index 97% rename from code/RemoveRedundantMaterials.cpp rename to code/PostProcessing/RemoveRedundantMaterials.cpp index 632bdca3f..49ec8f5c4 100644 --- a/code/RemoveRedundantMaterials.cpp +++ b/code/PostProcessing/RemoveRedundantMaterials.cpp @@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "RemoveRedundantMaterials.h" #include #include "ProcessHelper.h" -#include "MaterialSystem.h" +#include "Material/MaterialSystem.h" #include using namespace Assimp; @@ -57,7 +57,7 @@ using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer RemoveRedundantMatsProcess::RemoveRedundantMatsProcess() -: configFixedMaterials() { +: mConfigFixedMaterials() { // nothing to do here } @@ -80,7 +80,7 @@ bool RemoveRedundantMatsProcess::IsActive( unsigned int pFlags) const void RemoveRedundantMatsProcess::SetupProperties(const Importer* pImp) { // Get value of AI_CONFIG_PP_RRM_EXCLUDE_LIST - configFixedMaterials = pImp->GetPropertyString(AI_CONFIG_PP_RRM_EXCLUDE_LIST,""); + mConfigFixedMaterials = pImp->GetPropertyString(AI_CONFIG_PP_RRM_EXCLUDE_LIST,""); } // ------------------------------------------------------------------------------------------------ @@ -100,10 +100,10 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene) // If a list of materials to be excluded was given, match the list with // our imported materials and 'salt' all positive matches to ensure that // we get unique hashes later. - if (configFixedMaterials.length()) { + if (mConfigFixedMaterials.length()) { std::list strings; - ConvertListToStrings(configFixedMaterials,strings); + ConvertListToStrings(mConfigFixedMaterials,strings); for (unsigned int i = 0; i < pScene->mNumMaterials;++i) { aiMaterial* mat = pScene->mMaterials[i]; diff --git a/code/RemoveRedundantMaterials.h b/code/PostProcessing/RemoveRedundantMaterials.h similarity index 92% rename from code/RemoveRedundantMaterials.h rename to code/PostProcessing/RemoveRedundantMaterials.h index dbd4d44cc..1f32a0abf 100644 --- a/code/RemoveRedundantMaterials.h +++ b/code/PostProcessing/RemoveRedundantMaterials.h @@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_REMOVEREDUNDANTMATERIALS_H_INC #define AI_REMOVEREDUNDANTMATERIALS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include class RemoveRedundantMatsTest; @@ -57,8 +57,7 @@ namespace Assimp { /** RemoveRedundantMatsProcess: Post-processing step to remove redundant * materials from the imported scene. */ -class ASSIMP_API RemoveRedundantMatsProcess : public BaseProcess -{ +class ASSIMP_API RemoveRedundantMatsProcess : public BaseProcess { public: /// The default class constructor. RemoveRedundantMatsProcess(); @@ -66,7 +65,6 @@ public: /// The class destructor. ~RemoveRedundantMatsProcess(); -public: // ------------------------------------------------------------------- // Check whether step is active bool IsActive( unsigned int pFlags) const; @@ -79,27 +77,25 @@ public: // Setup import settings void SetupProperties(const Importer* pImp); - // ------------------------------------------------------------------- - /** @brief Set list of fixed (unmutable) materials + /** @brief Set list of fixed (inmutable) materials * @param fixed See #AI_CONFIG_PP_RRM_EXCLUDE_LIST */ void SetFixedMaterialsString(const std::string& fixed = "") { - configFixedMaterials = fixed; + mConfigFixedMaterials = fixed; } // ------------------------------------------------------------------- - /** @brief Get list of fixed (unmutable) materials + /** @brief Get list of fixed (inmutable) materials * @return See #AI_CONFIG_PP_RRM_EXCLUDE_LIST */ const std::string& GetFixedMaterialsString() const { - return configFixedMaterials; + return mConfigFixedMaterials; } private: - //! Configuration option: list of all fixed materials - std::string configFixedMaterials; + std::string mConfigFixedMaterials; }; } // end of namespace Assimp diff --git a/code/RemoveVCProcess.cpp b/code/PostProcessing/RemoveVCProcess.cpp similarity index 100% rename from code/RemoveVCProcess.cpp rename to code/PostProcessing/RemoveVCProcess.cpp diff --git a/code/RemoveVCProcess.h b/code/PostProcessing/RemoveVCProcess.h similarity index 99% rename from code/RemoveVCProcess.h rename to code/PostProcessing/RemoveVCProcess.h index 617d7b9b2..7bb21a833 100644 --- a/code/RemoveVCProcess.h +++ b/code/PostProcessing/RemoveVCProcess.h @@ -44,7 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_REMOVEVCPROCESS_H_INCLUDED #define AI_REMOVEVCPROCESS_H_INCLUDED -#include "BaseProcess.h" +#include "Common/BaseProcess.h" + #include class RemoveVCProcessTest; diff --git a/code/ScaleProcess.cpp b/code/PostProcessing/ScaleProcess.cpp similarity index 100% rename from code/ScaleProcess.cpp rename to code/PostProcessing/ScaleProcess.cpp diff --git a/code/ScaleProcess.h b/code/PostProcessing/ScaleProcess.h similarity index 98% rename from code/ScaleProcess.h rename to code/PostProcessing/ScaleProcess.h index 55146ae06..256737875 100644 --- a/code/ScaleProcess.h +++ b/code/PostProcessing/ScaleProcess.h @@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #pragma once -#include "BaseProcess.h" +#include "Common/BaseProcess.h" struct aiNode; diff --git a/code/SortByPTypeProcess.cpp b/code/PostProcessing/SortByPTypeProcess.cpp similarity index 95% rename from code/SortByPTypeProcess.cpp rename to code/PostProcessing/SortByPTypeProcess.cpp index 2e0cc5400..be8405a17 100644 --- a/code/SortByPTypeProcess.cpp +++ b/code/PostProcessing/SortByPTypeProcess.cpp @@ -57,8 +57,8 @@ using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer SortByPTypeProcess::SortByPTypeProcess() -{ - configRemoveMeshes = 0; +: mConfigRemoveMeshes( 0 ) { + // empty } // ------------------------------------------------------------------------------------------------ @@ -78,7 +78,7 @@ bool SortByPTypeProcess::IsActive( unsigned int pFlags) const // ------------------------------------------------------------------------------------------------ void SortByPTypeProcess::SetupProperties(const Importer* pImp) { - configRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE,0); + mConfigRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE,0); } // ------------------------------------------------------------------------------------------------ @@ -172,7 +172,7 @@ void SortByPTypeProcess::Execute( aiScene* pScene) { } if (1 == num) { - if (!(configRemoveMeshes & mesh->mPrimitiveTypes)) { + if (!(mConfigRemoveMeshes & mesh->mPrimitiveTypes)) { *meshIdx = static_cast( outMeshes.size() ); outMeshes.push_back(mesh); } else { @@ -206,7 +206,7 @@ void SortByPTypeProcess::Execute( aiScene* pScene) { VertexWeightTable* avw = ComputeVertexBoneWeightTable(mesh); for (unsigned int real = 0; real < 4; ++real,++meshIdx) { - if ( !aiNumPerPType[real] || configRemoveMeshes & (1u << real)) + if ( !aiNumPerPType[real] || mConfigRemoveMeshes & (1u << real)) { continue; } @@ -392,10 +392,10 @@ void SortByPTypeProcess::Execute( aiScene* pScene) { { char buffer[1024]; ::ai_snprintf(buffer,1024,"Points: %u%s, Lines: %u%s, Triangles: %u%s, Polygons: %u%s (Meshes, X = removed)", - aiNumMeshesPerPType[0], ((configRemoveMeshes & aiPrimitiveType_POINT) ? "X" : ""), - aiNumMeshesPerPType[1], ((configRemoveMeshes & aiPrimitiveType_LINE) ? "X" : ""), - aiNumMeshesPerPType[2], ((configRemoveMeshes & aiPrimitiveType_TRIANGLE) ? "X" : ""), - aiNumMeshesPerPType[3], ((configRemoveMeshes & aiPrimitiveType_POLYGON) ? "X" : "")); + aiNumMeshesPerPType[0], ((mConfigRemoveMeshes & aiPrimitiveType_POINT) ? "X" : ""), + aiNumMeshesPerPType[1], ((mConfigRemoveMeshes & aiPrimitiveType_LINE) ? "X" : ""), + aiNumMeshesPerPType[2], ((mConfigRemoveMeshes & aiPrimitiveType_TRIANGLE) ? "X" : ""), + aiNumMeshesPerPType[3], ((mConfigRemoveMeshes & aiPrimitiveType_POLYGON) ? "X" : "")); ASSIMP_LOG_INFO(buffer); ASSIMP_LOG_DEBUG("SortByPTypeProcess finished"); } diff --git a/code/SortByPTypeProcess.h b/code/PostProcessing/SortByPTypeProcess.h similarity index 95% rename from code/SortByPTypeProcess.h rename to code/PostProcessing/SortByPTypeProcess.h index c9d9924d8..1d7ccfc15 100644 --- a/code/SortByPTypeProcess.h +++ b/code/PostProcessing/SortByPTypeProcess.h @@ -45,10 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_SORTBYPTYPEPROCESS_H_INC #define AI_SORTBYPTYPEPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include class SortByPTypeProcessTest; + namespace Assimp { @@ -57,14 +58,11 @@ namespace Assimp { * A mesh with 5 lines, 3 points and 145 triangles would be split in 3 * submeshes. */ -class ASSIMP_API SortByPTypeProcess : public BaseProcess -{ +class ASSIMP_API SortByPTypeProcess : public BaseProcess { public: - SortByPTypeProcess(); ~SortByPTypeProcess(); -public: // ------------------------------------------------------------------- bool IsActive( unsigned int pFlags) const; @@ -75,8 +73,7 @@ public: void SetupProperties(const Importer* pImp); private: - - int configRemoveMeshes; + int mConfigRemoveMeshes; }; diff --git a/code/SplitLargeMeshes.cpp b/code/PostProcessing/SplitLargeMeshes.cpp similarity index 100% rename from code/SplitLargeMeshes.cpp rename to code/PostProcessing/SplitLargeMeshes.cpp diff --git a/code/SplitLargeMeshes.h b/code/PostProcessing/SplitLargeMeshes.h similarity index 98% rename from code/SplitLargeMeshes.h rename to code/PostProcessing/SplitLargeMeshes.h index 77f089ce7..3f90576ea 100644 --- a/code/SplitLargeMeshes.h +++ b/code/PostProcessing/SplitLargeMeshes.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2019, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -40,21 +39,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------- */ -/** @file Defines a post processing step to split large meshes into submeshes +/** @file Defines a post processing step to split large meshes into sub-meshes */ #ifndef AI_SPLITLARGEMESHES_H_INC #define AI_SPLITLARGEMESHES_H_INC #include -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include #include +// Forward declarations class SplitLargeMeshesTest; -namespace Assimp -{ +namespace Assimp { class SplitLargeMeshesProcess_Triangle; class SplitLargeMeshesProcess_Vertex; diff --git a/code/TextureTransform.cpp b/code/PostProcessing/TextureTransform.cpp similarity index 100% rename from code/TextureTransform.cpp rename to code/PostProcessing/TextureTransform.cpp diff --git a/code/TextureTransform.h b/code/PostProcessing/TextureTransform.h similarity index 99% rename from code/TextureTransform.h rename to code/PostProcessing/TextureTransform.h index c556ff5d8..2a5d623d7 100644 --- a/code/TextureTransform.h +++ b/code/PostProcessing/TextureTransform.h @@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define AI_TEXTURE_TRANSFORM_H_INCLUDED #include -#include "BaseProcess.h" +#include "Common/BaseProcess.h" #include #include diff --git a/code/TriangulateProcess.cpp b/code/PostProcessing/TriangulateProcess.cpp similarity index 99% rename from code/TriangulateProcess.cpp rename to code/PostProcessing/TriangulateProcess.cpp index 0f68f47dd..1040836bb 100644 --- a/code/TriangulateProcess.cpp +++ b/code/PostProcessing/TriangulateProcess.cpp @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2019, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -60,9 +58,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * a file */ #ifndef ASSIMP_BUILD_NO_TRIANGULATE_PROCESS -#include "TriangulateProcess.h" -#include "ProcessHelper.h" -#include "PolyTools.h" + +#include "PostProcessing/TriangulateProcess.h" +#include "PostProcessing/ProcessHelper.h" +#include "Common/PolyTools.h" + #include //#define AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING diff --git a/code/TriangulateProcess.h b/code/PostProcessing/TriangulateProcess.h similarity index 97% rename from code/TriangulateProcess.h rename to code/PostProcessing/TriangulateProcess.h index 47bd2115a..916b5103d 100644 --- a/code/TriangulateProcess.h +++ b/code/PostProcessing/TriangulateProcess.h @@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_TRIANGULATEPROCESS_H_INC #define AI_TRIANGULATEPROCESS_H_INC -#include "BaseProcess.h" +#include "Common/BaseProcess.h" struct aiMesh; @@ -59,14 +59,11 @@ namespace Assimp { * into triangles. You usually want this to happen because the graphics cards * need their data as triangles. */ -class ASSIMP_API TriangulateProcess : public BaseProcess -{ +class ASSIMP_API TriangulateProcess : public BaseProcess { public: - TriangulateProcess(); ~TriangulateProcess(); -public: // ------------------------------------------------------------------- /** Returns whether the processing step is present in the given flag field. * @param pFlags The processing flags the importer was called with. A bitwise @@ -82,7 +79,6 @@ public: */ void Execute( aiScene* pScene); -public: // ------------------------------------------------------------------- /** Triangulates the given mesh. * @param pMesh The mesh to triangulate. diff --git a/code/ValidateDataStructure.cpp b/code/PostProcessing/ValidateDataStructure.cpp similarity index 100% rename from code/ValidateDataStructure.cpp rename to code/PostProcessing/ValidateDataStructure.cpp diff --git a/code/ValidateDataStructure.h b/code/PostProcessing/ValidateDataStructure.h similarity index 99% rename from code/ValidateDataStructure.h rename to code/PostProcessing/ValidateDataStructure.h index bd21e8854..0b891ef41 100644 --- a/code/ValidateDataStructure.h +++ b/code/PostProcessing/ValidateDataStructure.h @@ -48,7 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "BaseProcess.h" + +#include "Common/BaseProcess.h" struct aiBone; struct aiMesh; diff --git a/code/Q3BSPFileData.h b/code/Q3BSP/Q3BSPFileData.h similarity index 100% rename from code/Q3BSPFileData.h rename to code/Q3BSP/Q3BSPFileData.h diff --git a/code/Q3BSPFileImporter.cpp b/code/Q3BSP/Q3BSPFileImporter.cpp similarity index 100% rename from code/Q3BSPFileImporter.cpp rename to code/Q3BSP/Q3BSPFileImporter.cpp diff --git a/code/Q3BSPFileImporter.h b/code/Q3BSP/Q3BSPFileImporter.h similarity index 100% rename from code/Q3BSPFileImporter.h rename to code/Q3BSP/Q3BSPFileImporter.h diff --git a/code/Q3BSPFileParser.cpp b/code/Q3BSP/Q3BSPFileParser.cpp similarity index 100% rename from code/Q3BSPFileParser.cpp rename to code/Q3BSP/Q3BSPFileParser.cpp diff --git a/code/Q3BSPFileParser.h b/code/Q3BSP/Q3BSPFileParser.h similarity index 100% rename from code/Q3BSPFileParser.h rename to code/Q3BSP/Q3BSPFileParser.h diff --git a/code/Q3BSPZipArchive.cpp b/code/Q3BSP/Q3BSPZipArchive.cpp similarity index 96% rename from code/Q3BSPZipArchive.cpp rename to code/Q3BSP/Q3BSPZipArchive.cpp index 0b6664842..931f2b905 100644 --- a/code/Q3BSPZipArchive.cpp +++ b/code/Q3BSP/Q3BSPZipArchive.cpp @@ -123,6 +123,15 @@ int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) { zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) { zlib_filefunc_def mapping; +#ifdef ASSIMP_USE_HUNTER + mapping.zopen_file = (open_file_func)open; + mapping.zread_file = (read_file_func)read; + mapping.zwrite_file = (write_file_func)write; + mapping.ztell_file = (tell_file_func)tell; + mapping.zseek_file = (seek_file_func)seek; + mapping.zclose_file = (close_file_func)close; + mapping.zerror_file = (error_file_func)testerror; +#else mapping.zopen_file = open; mapping.zread_file = read; mapping.zwrite_file = write; @@ -130,6 +139,7 @@ zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) { mapping.zseek_file = seek; mapping.zclose_file = close; mapping.zerror_file = testerror; +#endif mapping.opaque = (voidpf) pIOHandler; return mapping; diff --git a/code/Q3BSPZipArchive.h b/code/Q3BSP/Q3BSPZipArchive.h similarity index 98% rename from code/Q3BSPZipArchive.h rename to code/Q3BSP/Q3BSPZipArchive.h index 2fdc781f8..db68925a8 100644 --- a/code/Q3BSPZipArchive.h +++ b/code/Q3BSP/Q3BSPZipArchive.h @@ -42,7 +42,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_Q3BSP_ZIPARCHIVE_H_INC #define AI_Q3BSP_ZIPARCHIVE_H_INC -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif #include #include #include diff --git a/code/Q3DLoader.cpp b/code/Q3D/Q3DLoader.cpp similarity index 100% rename from code/Q3DLoader.cpp rename to code/Q3D/Q3DLoader.cpp diff --git a/code/Q3DLoader.h b/code/Q3D/Q3DLoader.h similarity index 100% rename from code/Q3DLoader.h rename to code/Q3D/Q3DLoader.h diff --git a/code/RawLoader.cpp b/code/Raw/RawLoader.cpp similarity index 100% rename from code/RawLoader.cpp rename to code/Raw/RawLoader.cpp diff --git a/code/RawLoader.h b/code/Raw/RawLoader.h similarity index 100% rename from code/RawLoader.h rename to code/Raw/RawLoader.h diff --git a/code/SIBImporter.cpp b/code/SIB/SIBImporter.cpp similarity index 99% rename from code/SIBImporter.cpp rename to code/SIB/SIBImporter.cpp index cfa65520e..20cdc8009 100644 --- a/code/SIBImporter.cpp +++ b/code/SIB/SIBImporter.cpp @@ -59,8 +59,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -//#include "../contrib/ConvertUTF/ConvertUTF.h" -#include "../contrib/utf8cpp/source/utf8.h" +#ifdef ASSIMP_USE_HUNTER +# include +#else +//# include "../contrib/ConvertUTF/ConvertUTF.h" +# include "../contrib/utf8cpp/source/utf8.h" +#endif #include #include #include diff --git a/code/SIBImporter.h b/code/SIB/SIBImporter.h similarity index 100% rename from code/SIBImporter.h rename to code/SIB/SIBImporter.h diff --git a/code/SMDLoader.cpp b/code/SMD/SMDLoader.cpp similarity index 100% rename from code/SMDLoader.cpp rename to code/SMD/SMDLoader.cpp diff --git a/code/SMDLoader.h b/code/SMD/SMDLoader.h similarity index 100% rename from code/SMDLoader.h rename to code/SMD/SMDLoader.h diff --git a/code/STLExporter.cpp b/code/STL/STLExporter.cpp similarity index 99% rename from code/STLExporter.cpp rename to code/STL/STLExporter.cpp index d56c42835..43bc752ae 100644 --- a/code/STLExporter.cpp +++ b/code/STL/STLExporter.cpp @@ -111,7 +111,7 @@ STLExporter::STLExporter(const char* _filename, const aiScene* pScene, bool expo // make sure that all formatting happens using the standard, C locale and not the user's current locale const std::locale& l = std::locale("C"); mOutput.imbue(l); - mOutput.precision(16); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); if (binary) { char buf[80] = {0} ; buf[0] = 'A'; buf[1] = 's'; buf[2] = 's'; buf[3] = 'i'; buf[4] = 'm'; buf[5] = 'p'; diff --git a/code/STLExporter.h b/code/STL/STLExporter.h similarity index 100% rename from code/STLExporter.h rename to code/STL/STLExporter.h diff --git a/code/STLLoader.cpp b/code/STL/STLLoader.cpp similarity index 99% rename from code/STLLoader.cpp rename to code/STL/STLLoader.cpp index c615561a8..c7144e444 100644 --- a/code/STLLoader.cpp +++ b/code/STL/STLLoader.cpp @@ -278,6 +278,7 @@ void STLImporter::LoadASCIIFile( aiNode *root ) { } std::string name( szMe, temp ); node->mName.Set( name.c_str() ); + pMesh->mName.Set( name.c_str() ); //pScene->mRootNode->mName.length = temp; //memcpy(pScene->mRootNode->mName.data,szMe,temp); //pScene->mRootNode->mName.data[temp] = '\0'; diff --git a/code/STLLoader.h b/code/STL/STLLoader.h similarity index 100% rename from code/STLLoader.h rename to code/STL/STLLoader.h diff --git a/code/STEPFile.h b/code/Step/STEPFile.h similarity index 99% rename from code/STEPFile.h rename to code/Step/STEPFile.h index ac3280c21..d99b34b3c 100644 --- a/code/STEPFile.h +++ b/code/Step/STEPFile.h @@ -50,7 +50,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "FBXDocument.h" //ObjectMap::value_type +#include "FBX/FBXDocument.h" //ObjectMap::value_type + #include // diff --git a/code/StepExporter.cpp b/code/Step/StepExporter.cpp similarity index 97% rename from code/StepExporter.cpp rename to code/Step/StepExporter.cpp index 02e521247..70035d9ea 100644 --- a/code/StepExporter.cpp +++ b/code/Step/StepExporter.cpp @@ -45,23 +45,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_STEP_EXPORTER -#include "StepExporter.h" -#include "ConvertToLHProcess.h" +#include "Step/StepExporter.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include #include #include #include +#include +#include +#include +#include +#include + #include #include #include #include #include #include -#include -#include -#include -#include -#include // #if _MSC_VER > 1500 || (defined __GNUC___) @@ -141,15 +143,15 @@ namespace { // ------------------------------------------------------------------------------------------------ // Constructor for a specific scene to export StepExporter::StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, - const std::string& file, const ExportProperties* pProperties): - mProperties(pProperties),mIOSystem(pIOSystem),mFile(file), mPath(path), - mScene(pScene), endstr(";\n") { - CollectTrafos(pScene->mRootNode, trafos); - CollectMeshes(pScene->mRootNode, meshes); + const std::string& file, const ExportProperties* pProperties) : + mProperties(pProperties), mIOSystem(pIOSystem), mFile(file), mPath(path), + mScene(pScene), endstr(";\n") { + CollectTrafos(pScene->mRootNode, trafos); + CollectMeshes(pScene->mRootNode, meshes); // make sure that all formatting happens using the standard, C locale and not the user's current locale - mOutput.imbue( std::locale("C") ); - mOutput.precision(16); + mOutput.imbue(std::locale("C")); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); // start writing WriteFile(); @@ -164,7 +166,7 @@ void StepExporter::WriteFile() mOutput.setf(std::ios::fixed); // precision for double // see http://stackoverflow.com/questions/554063/how-do-i-print-a-double-value-with-full-precision-using-cout - mOutput.precision(16); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); // standard color aiColor4D fColor; diff --git a/code/StepExporter.h b/code/Step/StepExporter.h similarity index 100% rename from code/StepExporter.h rename to code/Step/StepExporter.h diff --git a/code/TerragenLoader.cpp b/code/Terragen/TerragenLoader.cpp similarity index 100% rename from code/TerragenLoader.cpp rename to code/Terragen/TerragenLoader.cpp diff --git a/code/TerragenLoader.h b/code/Terragen/TerragenLoader.h similarity index 100% rename from code/TerragenLoader.h rename to code/Terragen/TerragenLoader.h diff --git a/code/UnrealLoader.cpp b/code/Unreal/UnrealLoader.cpp similarity index 99% rename from code/UnrealLoader.cpp rename to code/Unreal/UnrealLoader.cpp index 778aef59d..0bd4650d0 100644 --- a/code/UnrealLoader.cpp +++ b/code/Unreal/UnrealLoader.cpp @@ -52,12 +52,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_3D_IMPORTER -#include "UnrealLoader.h" +#include "Unreal/UnrealLoader.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include #include #include -#include "ConvertToLHProcess.h" - #include #include #include diff --git a/code/UnrealLoader.h b/code/Unreal/UnrealLoader.h similarity index 100% rename from code/UnrealLoader.h rename to code/Unreal/UnrealLoader.h diff --git a/code/XFileExporter.cpp b/code/X/XFileExporter.cpp similarity index 98% rename from code/XFileExporter.cpp rename to code/X/XFileExporter.cpp index baa478226..ae9fd58fc 100644 --- a/code/XFileExporter.cpp +++ b/code/X/XFileExporter.cpp @@ -45,21 +45,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_X_EXPORTER -#include "XFileExporter.h" -#include "ConvertToLHProcess.h" +#include "X/XFileExporter.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include #include #include #include #include -#include -#include -#include #include #include #include #include +#include +#include +#include + using namespace Assimp; namespace Assimp @@ -111,7 +113,7 @@ XFileExporter::XFileExporter(const aiScene* pScene, IOSystem* pIOSystem, const s { // make sure that all formatting happens using the standard, C locale and not the user's current locale mOutput.imbue( std::locale("C") ); - mOutput.precision(16); + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); // start writing WriteFile(); @@ -132,7 +134,7 @@ void XFileExporter::WriteFile() { // note, that all realnumber values must be comma separated in x files mOutput.setf(std::ios::fixed); - mOutput.precision(16); // precision for double + mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); // precision for ai_real // entry of writing the file WriteHeader(); diff --git a/code/XFileExporter.h b/code/X/XFileExporter.h similarity index 100% rename from code/XFileExporter.h rename to code/X/XFileExporter.h diff --git a/code/XFileHelper.h b/code/X/XFileHelper.h similarity index 100% rename from code/XFileHelper.h rename to code/X/XFileHelper.h diff --git a/code/XFileImporter.cpp b/code/X/XFileImporter.cpp similarity index 98% rename from code/XFileImporter.cpp rename to code/X/XFileImporter.cpp index e9335cfaa..be7256d5c 100644 --- a/code/XFileImporter.cpp +++ b/code/X/XFileImporter.cpp @@ -44,10 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_X_IMPORTER -#include "XFileImporter.h" -#include "XFileParser.h" +#include "X/XFileImporter.h" +#include "X/XFileParser.h" +#include "PostProcessing/ConvertToLHProcess.h" + #include -#include "ConvertToLHProcess.h" #include #include #include @@ -331,7 +332,7 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec // collect vertex data for indices of this face for( unsigned int d = 0; d < df.mNumIndices; ++d ) { - df.mIndices[d] = newIndex; + df.mIndices[ d ] = newIndex; const unsigned int newIdx( pf.mIndices[ d ] ); if ( newIdx > sourceMesh->mPositions.size() ) { continue; @@ -343,7 +344,10 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec mesh->mVertices[newIndex] = sourceMesh->mPositions[pf.mIndices[d]]; // Normal, if present if ( mesh->HasNormals() ) { - mesh->mNormals[ newIndex ] = sourceMesh->mNormals[ sourceMesh->mNormFaces[ f ].mIndices[ d ] ]; + if ( sourceMesh->mNormFaces[ f ].mIndices.size() > d ) { + const size_t idx( sourceMesh->mNormFaces[ f ].mIndices[ d ] ); + mesh->mNormals[ newIndex ] = sourceMesh->mNormals[ idx ]; + } } // texture coord sets diff --git a/code/XFileImporter.h b/code/X/XFileImporter.h similarity index 98% rename from code/XFileImporter.h rename to code/X/XFileImporter.h index d1b8d3f47..7d12b6fdf 100644 --- a/code/XFileImporter.h +++ b/code/X/XFileImporter.h @@ -58,13 +58,13 @@ struct aiNode; namespace Assimp { namespace XFile { -struct Scene; -struct Node; + struct Scene; + struct Node; } // --------------------------------------------------------------------------- /** The XFileImporter is a worker class capable of importing a scene from a - * DirectX file .x + * DirectX file .x */ class XFileImporter : public BaseImporter { public: diff --git a/code/XFileParser.cpp b/code/X/XFileParser.cpp similarity index 98% rename from code/XFileParser.cpp rename to code/X/XFileParser.cpp index ed715a19d..08d3c88da 100644 --- a/code/XFileParser.cpp +++ b/code/X/XFileParser.cpp @@ -583,24 +583,30 @@ void XFileParser::ParseDataObjectMeshNormals( Mesh* pMesh) pMesh->mNormals.resize( numNormals); // read normal vectors - for( unsigned int a = 0; a < numNormals; a++) + for( unsigned int a = 0; a < numNormals; ++a) { pMesh->mNormals[a] = ReadVector3(); + } // read normal indices unsigned int numFaces = ReadInt(); - if( numFaces != pMesh->mPosFaces.size()) + if( numFaces != pMesh->mPosFaces.size()) { ThrowException( "Normal face count does not match vertex face count."); + } - for( unsigned int a = 0; a < numFaces; a++) - { - unsigned int numIndices = ReadInt(); - pMesh->mNormFaces.push_back( Face()); - Face& face = pMesh->mNormFaces.back(); + // do not crah when no face definitions are there + if (numFaces > 0) { + // normal face creation + pMesh->mNormFaces.resize( pMesh->mNormFaces.size() + numFaces ); + for( unsigned int a = 0; a < numFaces; ++a ) { + unsigned int numIndices = ReadInt(); + pMesh->mNormFaces.push_back( Face() ); + Face& face = pMesh->mNormFaces.back(); + for( unsigned int b = 0; b < numIndices; ++b ) { + face.mIndices.push_back( ReadInt()); + } - for( unsigned int b = 0; b < numIndices; b++) - face.mIndices.push_back( ReadInt()); - - TestForSeparator(); + TestForSeparator(); + } } CheckForClosingBrace(); diff --git a/code/XFileParser.h b/code/X/XFileParser.h similarity index 100% rename from code/XFileParser.h rename to code/X/XFileParser.h diff --git a/code/FIReader.cpp b/code/X3D/FIReader.cpp old mode 100755 new mode 100644 similarity index 99% rename from code/FIReader.cpp rename to code/X3D/FIReader.cpp index 2116316ca..9bb2c69f6 --- a/code/FIReader.cpp +++ b/code/X3D/FIReader.cpp @@ -60,7 +60,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include "../contrib/utf8cpp/source/utf8.h" +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include "../contrib/utf8cpp/source/utf8.h" +#endif #include #include #include diff --git a/code/FIReader.hpp b/code/X3D/FIReader.hpp similarity index 98% rename from code/FIReader.hpp rename to code/X3D/FIReader.hpp index 29e3ddb1b..2c92239ac 100644 --- a/code/FIReader.hpp +++ b/code/X3D/FIReader.hpp @@ -57,7 +57,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include //#include //#include -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif namespace Assimp { diff --git a/code/X3DExporter.cpp b/code/X3D/X3DExporter.cpp similarity index 100% rename from code/X3DExporter.cpp rename to code/X3D/X3DExporter.cpp diff --git a/code/X3DExporter.hpp b/code/X3D/X3DExporter.hpp similarity index 100% rename from code/X3DExporter.hpp rename to code/X3D/X3DExporter.hpp diff --git a/code/X3DImporter.cpp b/code/X3D/X3DImporter.cpp similarity index 100% rename from code/X3DImporter.cpp rename to code/X3D/X3DImporter.cpp diff --git a/code/X3DImporter.hpp b/code/X3D/X3DImporter.hpp similarity index 100% rename from code/X3DImporter.hpp rename to code/X3D/X3DImporter.hpp diff --git a/code/X3DImporter_Geometry2D.cpp b/code/X3D/X3DImporter_Geometry2D.cpp similarity index 100% rename from code/X3DImporter_Geometry2D.cpp rename to code/X3D/X3DImporter_Geometry2D.cpp diff --git a/code/X3DImporter_Geometry3D.cpp b/code/X3D/X3DImporter_Geometry3D.cpp similarity index 100% rename from code/X3DImporter_Geometry3D.cpp rename to code/X3D/X3DImporter_Geometry3D.cpp diff --git a/code/X3DImporter_Group.cpp b/code/X3D/X3DImporter_Group.cpp similarity index 100% rename from code/X3DImporter_Group.cpp rename to code/X3D/X3DImporter_Group.cpp diff --git a/code/X3DImporter_Light.cpp b/code/X3D/X3DImporter_Light.cpp similarity index 100% rename from code/X3DImporter_Light.cpp rename to code/X3D/X3DImporter_Light.cpp diff --git a/code/X3DImporter_Macro.hpp b/code/X3D/X3DImporter_Macro.hpp similarity index 100% rename from code/X3DImporter_Macro.hpp rename to code/X3D/X3DImporter_Macro.hpp diff --git a/code/X3DImporter_Metadata.cpp b/code/X3D/X3DImporter_Metadata.cpp similarity index 100% rename from code/X3DImporter_Metadata.cpp rename to code/X3D/X3DImporter_Metadata.cpp diff --git a/code/X3DImporter_Networking.cpp b/code/X3D/X3DImporter_Networking.cpp similarity index 100% rename from code/X3DImporter_Networking.cpp rename to code/X3D/X3DImporter_Networking.cpp diff --git a/code/X3DImporter_Node.hpp b/code/X3D/X3DImporter_Node.hpp similarity index 100% rename from code/X3DImporter_Node.hpp rename to code/X3D/X3DImporter_Node.hpp diff --git a/code/X3DImporter_Postprocess.cpp b/code/X3D/X3DImporter_Postprocess.cpp similarity index 100% rename from code/X3DImporter_Postprocess.cpp rename to code/X3D/X3DImporter_Postprocess.cpp diff --git a/code/X3DImporter_Rendering.cpp b/code/X3D/X3DImporter_Rendering.cpp similarity index 100% rename from code/X3DImporter_Rendering.cpp rename to code/X3D/X3DImporter_Rendering.cpp diff --git a/code/X3DImporter_Shape.cpp b/code/X3D/X3DImporter_Shape.cpp similarity index 100% rename from code/X3DImporter_Shape.cpp rename to code/X3D/X3DImporter_Shape.cpp diff --git a/code/X3DImporter_Texturing.cpp b/code/X3D/X3DImporter_Texturing.cpp similarity index 100% rename from code/X3DImporter_Texturing.cpp rename to code/X3D/X3DImporter_Texturing.cpp diff --git a/code/X3DVocabulary.cpp b/code/X3D/X3DVocabulary.cpp similarity index 100% rename from code/X3DVocabulary.cpp rename to code/X3D/X3DVocabulary.cpp diff --git a/code/XGLLoader.cpp b/code/XGL/XGLLoader.cpp similarity index 100% rename from code/XGLLoader.cpp rename to code/XGL/XGLLoader.cpp diff --git a/code/XGLLoader.h b/code/XGL/XGLLoader.h similarity index 100% rename from code/XGLLoader.h rename to code/XGL/XGLLoader.h diff --git a/code/glTFAsset.h b/code/glTF/glTFAsset.h similarity index 99% rename from code/glTFAsset.h rename to code/glTF/glTFAsset.h index 92b7dd9d1..359917b95 100644 --- a/code/glTFAsset.h +++ b/code/glTF/glTFAsset.h @@ -52,6 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER +#include + #include #include #include diff --git a/code/glTFAsset.inl b/code/glTF/glTFAsset.inl similarity index 100% rename from code/glTFAsset.inl rename to code/glTF/glTFAsset.inl diff --git a/code/glTFAssetWriter.h b/code/glTF/glTFAssetWriter.h similarity index 100% rename from code/glTFAssetWriter.h rename to code/glTF/glTFAssetWriter.h diff --git a/code/glTFAssetWriter.inl b/code/glTF/glTFAssetWriter.inl similarity index 100% rename from code/glTFAssetWriter.inl rename to code/glTF/glTFAssetWriter.inl diff --git a/code/glTFExporter.cpp b/code/glTF/glTFExporter.cpp similarity index 99% rename from code/glTFExporter.cpp rename to code/glTF/glTFExporter.cpp index 6bf7415d3..3bd944bb6 100644 --- a/code/glTFExporter.cpp +++ b/code/glTF/glTFExporter.cpp @@ -42,14 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER -#include "glTFExporter.h" +#include "glTF/glTFExporter.h" +#include "glTF/glTFAssetWriter.h" +#include "PostProcessing/SplitLargeMeshes.h" #include #include #include - -#include "SplitLargeMeshes.h" - #include #include #include @@ -61,8 +60,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "glTFAssetWriter.h" - #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC // Header files, Open3DGC. # include diff --git a/code/glTFExporter.h b/code/glTF/glTFExporter.h similarity index 100% rename from code/glTFExporter.h rename to code/glTF/glTFExporter.h diff --git a/code/glTFImporter.cpp b/code/glTF/glTFImporter.cpp old mode 100755 new mode 100644 similarity index 98% rename from code/glTFImporter.cpp rename to code/glTF/glTFImporter.cpp index 57566b463..146d7453e --- a/code/glTFImporter.cpp +++ b/code/glTF/glTFImporter.cpp @@ -42,10 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER -#include "glTFImporter.h" +#include "glTF/glTFImporter.h" +#include "glTF/glTFAsset.h" +#include "glTF/glTFAssetWriter.h" +#include "PostProcessing/MakeVerboseFormat.h" + #include #include - #include #include #include @@ -54,16 +57,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -#include "MakeVerboseFormat.h" - -#include "glTFAsset.h" -// This is included here so WriteLazyDict's definition is found. -#include "glTFAssetWriter.h" - using namespace Assimp; using namespace glTF; - // // glTFImporter // @@ -717,7 +713,11 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r) } } -void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { +void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) +{ + // clean all member arrays + meshOffsets.clear(); + embeddedTexIdxs.clear(); this->mScene = pScene; diff --git a/code/glTFImporter.h b/code/glTF/glTFImporter.h similarity index 100% rename from code/glTFImporter.h rename to code/glTF/glTFImporter.h diff --git a/code/glTF2Asset.h b/code/glTF2/glTF2Asset.h similarity index 99% rename from code/glTF2Asset.h rename to code/glTF2/glTF2Asset.h index 2937c0ce9..70f92df5b 100644 --- a/code/glTF2Asset.h +++ b/code/glTF2/glTF2Asset.h @@ -52,6 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER +#include + #include #include #include diff --git a/code/glTF2Asset.inl b/code/glTF2/glTF2Asset.inl old mode 100755 new mode 100644 similarity index 100% rename from code/glTF2Asset.inl rename to code/glTF2/glTF2Asset.inl diff --git a/code/glTF2AssetWriter.h b/code/glTF2/glTF2AssetWriter.h similarity index 100% rename from code/glTF2AssetWriter.h rename to code/glTF2/glTF2AssetWriter.h diff --git a/code/glTF2AssetWriter.inl b/code/glTF2/glTF2AssetWriter.inl similarity index 100% rename from code/glTF2AssetWriter.inl rename to code/glTF2/glTF2AssetWriter.inl diff --git a/code/glTF2Exporter.cpp b/code/glTF2/glTF2Exporter.cpp similarity index 99% rename from code/glTF2Exporter.cpp rename to code/glTF2/glTF2Exporter.cpp index 655b4fc7d..4724c2ef4 100644 --- a/code/glTF2Exporter.cpp +++ b/code/glTF2/glTF2Exporter.cpp @@ -42,14 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER -#include "glTF2Exporter.h" +#include "glTF2/glTF2Exporter.h" +#include "glTF2/glTF2AssetWriter.h" +#include "PostProcessing/SplitLargeMeshes.h" #include #include #include - -#include "SplitLargeMeshes.h" - #include #include #include @@ -61,8 +60,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "glTF2AssetWriter.h" - using namespace rapidjson; using namespace Assimp; diff --git a/code/glTF2Exporter.h b/code/glTF2/glTF2Exporter.h similarity index 100% rename from code/glTF2Exporter.h rename to code/glTF2/glTF2Exporter.h diff --git a/code/glTF2Importer.cpp b/code/glTF2/glTF2Importer.cpp old mode 100755 new mode 100644 similarity index 99% rename from code/glTF2Importer.cpp rename to code/glTF2/glTF2Importer.cpp index bb0f7ad8d..a2b18fc49 --- a/code/glTF2Importer.cpp +++ b/code/glTF2/glTF2Importer.cpp @@ -42,10 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER -#include "glTF2Importer.h" +#include "glTF2/glTF2Importer.h" +#include "glTF2/glTF2Asset.h" +#include "glTF2/glTF2AssetWriter.h" +#include "PostProcessing/MakeVerboseFormat.h" + #include #include - #include #include #include @@ -56,11 +59,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "MakeVerboseFormat.h" - -#include "glTF2Asset.h" -// This is included here so WriteLazyDict's definition is found. -#include "glTF2AssetWriter.h" #include #include @@ -68,7 +66,7 @@ using namespace Assimp; using namespace glTF2; namespace { - // generate bitangents from normals and tangents according to spec + // generate bi-tangents from normals and tangents according to spec struct Tangent { aiVector3D xyz; ai_real w; @@ -1130,7 +1128,11 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset& r) } } -void glTF2Importer::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { +void glTF2Importer::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) +{ + // clean all member arrays + meshOffsets.clear(); + embeddedTexIdxs.clear(); this->mScene = pScene; diff --git a/code/glTF2Importer.h b/code/glTF2/glTF2Importer.h similarity index 100% rename from code/glTF2Importer.h rename to code/glTF2/glTF2Importer.h diff --git a/code/res/resource.h b/code/res/resource.h index 37d39284f..c28c05073 100644 --- a/code/res/resource.h +++ b/code/res/resource.h @@ -2,8 +2,8 @@ // Microsoft Visual C++ generated include file. // Used by assimp.rc -// Nächste Standardwerte für neue Objekte -// +// Next standard values for new objects +// #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 101 diff --git a/contrib/irrXML/irrString.h b/contrib/irrXML/irrString.h index af21b8e51..ff0097b71 100644 --- a/contrib/irrXML/irrString.h +++ b/contrib/irrXML/irrString.h @@ -19,7 +19,7 @@ so you can assign unicode to string and ascii to string Note that the conversation between both is not done using an encoding. Known bugs: -Special characters like 'Ä', 'Ü' and 'Ö' are ignored in the +Special characters like 'Ä', 'Ãœ' and 'Ö' are ignored in the methods make_upper, make_lower and equals_ignore_case. */ template diff --git a/contrib/poly2tri/AUTHORS b/contrib/poly2tri/AUTHORS index 1736f14bb..aa390660d 100644 --- a/contrib/poly2tri/AUTHORS +++ b/contrib/poly2tri/AUTHORS @@ -1,7 +1,7 @@ Primary Contributors: Mason Green (C++, Python) - Thomas Åhlén (Java) + Thomas Ã…hlén (Java) Other Contributors: diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs b/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs index b110dae6a..cd1ef44eb 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -199,4 +199,4 @@ namespace DotZLib } #endregion -} \ No newline at end of file +} diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs b/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs index 9c8d60195..e7a88b9f4 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs b/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs index b0eb78a02..6ef6d8fab 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs b/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs index 9039f41f6..778a6794d 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs b/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs index 90c7c3b38..a48ed4974 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs b/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs index f0eada1d2..07b2f7a9b 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs b/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs index d295f2680..8e900ae20 100644 --- a/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs +++ b/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs @@ -1,5 +1,5 @@ // -// © Copyright Henrik Ravn 2004 +// © Copyright Henrik Ravn 2004 // // Use, modification and distribution are subject to the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/include/assimp/ParsingUtils.h b/include/assimp/ParsingUtils.h index ca30ce13b..6b9574fc6 100644 --- a/include/assimp/ParsingUtils.h +++ b/include/assimp/ParsingUtils.h @@ -196,8 +196,7 @@ bool GetNextLine( const char_t*& buffer, char_t out[ BufferSize ] ) { // --------------------------------------------------------------------------------- template -AI_FORCE_INLINE bool IsNumeric( char_t in) -{ +AI_FORCE_INLINE bool IsNumeric( char_t in) { return ( in >= '0' && in <= '9' ) || '-' == in || '+' == in; } diff --git a/include/assimp/aabb.h b/include/assimp/aabb.h new file mode 100644 index 000000000..a20f31742 --- /dev/null +++ b/include/assimp/aabb.h @@ -0,0 +1,76 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2019, assimp team + + + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the following +conditions are met: + +* Redistributions of source code must retain the above +copyright notice, this list of conditions and the +following disclaimer. + +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other +materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its +contributors may be used to endorse or promote products +derived from this software without specific prior +written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------- +*/ + +#pragma once +#ifndef AI_AABB_H_INC +#define AI_AABB_H_INC + +#include + +struct aiAABB { + C_STRUCT aiVector3D mMin; + C_STRUCT aiVector3D mMax; + +#ifdef __cplusplus + + aiAABB() + : mMin() + , mMax() { + // empty + } + + aiAABB(const aiVector3D &min, const aiVector3D &max ) + : mMin(min) + , mMax(max) { + // empty + } + + ~aiAABB() { + // empty + } + +#endif +}; + + +#endif diff --git a/include/assimp/camera.h b/include/assimp/camera.h index 99daf6993..dd45d90d1 100644 --- a/include/assimp/camera.h +++ b/include/assimp/camera.h @@ -162,7 +162,6 @@ struct aiCamera */ float mClipPlaneFar; - /** Screen aspect ratio. * * This is the ration between the width and the height of the diff --git a/include/assimp/config.h.in b/include/assimp/config.h.in index c42aa63da..c95f0e160 100644 --- a/include/assimp/config.h.in +++ b/include/assimp/config.h.in @@ -142,7 +142,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** @brief Specifies the maximum angle that may be between two vertex tangents * that their tangents and bi-tangents are smoothed. * - * This applies to the CalcTangentSpace-Step. The angle is specified + * This applies to the CalcTangentSpace-Step. TFvhe angle is specified * in degrees. The maximum value is 175. * Property type: float. Default value: 45 degrees */ diff --git a/include/assimp/defs.h b/include/assimp/defs.h index 4a177e3c3..05a5e3fd4 100644 --- a/include/assimp/defs.h +++ b/include/assimp/defs.h @@ -122,7 +122,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OPTIMIZEANIMS * OPTIMIZEGRAPH * GENENTITYMESHES - * FIXTEXTUREPATHS */ + * FIXTEXTUREPATHS + * GENBOUNDINGBOXES */ ////////////////////////////////////////////////////////////////////////// #ifdef _MSC_VER @@ -214,10 +215,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #endif #if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__)) -#error Currently, Borland is unsupported. Feel free to port Assimp. - -// "W8059 Packgröße der Struktur geändert" - +# error Currently, Borland is unsupported. Feel free to port Assimp. #endif @@ -243,10 +241,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. typedef double ai_real; typedef signed long long int ai_int; typedef unsigned long long int ai_uint; +#ifndef ASSIMP_AI_REAL_TEXT_PRECISION +#define ASSIMP_AI_REAL_TEXT_PRECISION 16 +#endif // ASSIMP_AI_REAL_TEXT_PRECISION #else // ASSIMP_DOUBLE_PRECISION typedef float ai_real; typedef signed int ai_int; typedef unsigned int ai_uint; +#ifndef ASSIMP_AI_REAL_TEXT_PRECISION +#define ASSIMP_AI_REAL_TEXT_PRECISION 8 +#endif // ASSIMP_AI_REAL_TEXT_PRECISION #endif // ASSIMP_DOUBLE_PRECISION ////////////////////////////////////////////////////////////////////////// @@ -267,6 +271,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define AI_DEG_TO_RAD(x) ((x)*(ai_real)0.0174532925) #define AI_RAD_TO_DEG(x) ((x)*(ai_real)57.2957795) +/* Numerical limits */ +static const ai_real ai_epsilon = (ai_real) 0.00001; + /* Support for big-endian builds */ #if defined(__BYTE_ORDER__) # if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) @@ -293,11 +300,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef _MSC_VER # define AI_NO_EXCEPT noexcept #else -# if (_MSC_VER == 1915 ) +# if (_MSC_VER >= 1915 ) # define AI_NO_EXCEPT noexcept # else # define AI_NO_EXCEPT # endif -#endif +#endif // _MSC_VER #endif // !! AI_DEFINES_H_INC diff --git a/include/assimp/irrXMLWrapper.h b/include/assimp/irrXMLWrapper.h index ec8ee7c76..77cfd5e47 100644 --- a/include/assimp/irrXMLWrapper.h +++ b/include/assimp/irrXMLWrapper.h @@ -44,7 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define INCLUDED_AI_IRRXML_WRAPPER // some long includes .... -#include +#ifdef ASSIMP_USE_HUNTER +# include +#else +# include +#endif #include "IOStream.hpp" #include "BaseImporter.h" #include @@ -91,14 +95,15 @@ public: stream->Read(&data[0],data.size(),1); // Remove null characters from the input sequence otherwise the parsing will utterly fail - unsigned int size = 0; - unsigned int size_max = static_cast(data.size()); - for(unsigned int i = 0; i < size_max; i++) { - if(data[i] != '\0') { - data[size++] = data[i]; - } + // std::find is usually much faster than manually iterating + // It is very unlikely that there will be any null characters + auto null_char_iter = std::find(data.begin(), data.end(), '\0'); + + while (null_char_iter != data.end()) + { + null_char_iter = data.erase(null_char_iter); + null_char_iter = std::find(null_char_iter, data.end(), '\0'); } - data.resize(size); BaseImporter::ConvertToUTF8(data); } diff --git a/include/assimp/mesh.h b/include/assimp/mesh.h index 36f3ed2af..f1628f1f5 100644 --- a/include/assimp/mesh.h +++ b/include/assimp/mesh.h @@ -48,7 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_MESH_H_INC #define AI_MESH_H_INC -#include "types.h" +#include +#include #ifdef __cplusplus extern "C" { @@ -714,6 +715,11 @@ struct aiMesh * Method of morphing when animeshes are specified. */ unsigned int mMethod; + + /** + * + */ + C_STRUCT aiAABB mAABB; #ifdef __cplusplus @@ -735,7 +741,8 @@ struct aiMesh , mMaterialIndex( 0 ) , mNumAnimMeshes( 0 ) , mAnimMeshes(nullptr) - , mMethod( 0 ) { + , mMethod( 0 ) + , mAABB() { for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a ) { mNumUVComponents[a] = 0; mTextureCoords[a] = nullptr; diff --git a/include/assimp/postprocess.h b/include/assimp/postprocess.h index c23a5490a..2a7441421 100644 --- a/include/assimp/postprocess.h +++ b/include/assimp/postprocess.h @@ -438,7 +438,7 @@ enum aiPostProcessSteps aiProcess_FindInstances = 0x100000, // ------------------------------------------------------------------------- - /**
A postprocessing step to reduce the number of meshes. + /**
A post-processing step to reduce the number of meshes. * * This will, in fact, reduce the number of draw calls. * @@ -450,7 +450,7 @@ enum aiPostProcessSteps // ------------------------------------------------------------------------- - /**
A postprocessing step to optimize the scene hierarchy. + /**
A post-processing step to optimize the scene hierarchy. * * Nodes without animations, bones, lights or cameras assigned are * collapsed and joined. @@ -514,7 +514,7 @@ enum aiPostProcessSteps // ------------------------------------------------------------------------- /**
This step splits meshes with many bones into sub-meshes so that each - * su-bmesh has fewer or as many bones as a given limit. + * sub-mesh has fewer or as many bones as a given limit. */ aiProcess_SplitByBoneCount = 0x2000000, @@ -541,7 +541,7 @@ enum aiPostProcessSteps * global scaling from your importer settings like in FBX. Use the flag * AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY from the global property table to configure this. * - * Use #AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY to setup the global scaing factor. + * Use #AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY to setup the global scaling factor. */ aiProcess_GlobalScale = 0x8000000, @@ -574,6 +574,11 @@ enum aiPostProcessSteps * This process gives sense back to aiProcess_JoinIdenticalVertices */ aiProcess_DropNormals = 0x40000000, + + // ------------------------------------------------------------------------- + /** + */ + aiProcess_GenBoundingBoxes = 0x80000000 }; diff --git a/include/assimp/types.h b/include/assimp/types.h index 748e4851f..331b8cd03 100644 --- a/include/assimp/types.h +++ b/include/assimp/types.h @@ -161,7 +161,14 @@ struct aiColor3D explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {} aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {} - /** Component-wise comparison */ + aiColor3D &operator=(const aiColor3D &o) { + r = o.r; + g = o.g; + b = o.b; + return *this; + } + + /** Component-wise comparison */ // TODO: add epsilon? bool operator == (const aiColor3D& other) const {return r == other.r && g == other.g && b == other.b;} diff --git a/port/AssimpNET/Readme.md b/port/AssimpNET/Readme.md index bcbfebab1..814cab3e0 100644 --- a/port/AssimpNET/Readme.md +++ b/port/AssimpNET/Readme.md @@ -1 +1 @@ -Please check the following git-repo for the source: https://bitbucket.org/Starnick/assimpnet +Please check the following git-repo for the source: https://github.com/kebby/assimp-net diff --git a/port/PyAssimp/pyassimp/core.py b/port/PyAssimp/pyassimp/core.py index 44163a434..c346e2652 100644 --- a/port/PyAssimp/pyassimp/core.py +++ b/port/PyAssimp/pyassimp/core.py @@ -82,7 +82,8 @@ def call_init(obj, caller = None): _init(obj,parent=caller) def _is_init_type(obj): - if helper.hasattr_silent(obj,'contents'): #pointer + + if obj and helper.hasattr_silent(obj,'contents'): #pointer return _is_init_type(obj[0]) # null-pointer case that arises when we reach a mesh attribute # like mBitangents which use mNumVertices rather than mNumBitangents diff --git a/port/PyAssimp/pyassimp/helper.py b/port/PyAssimp/pyassimp/helper.py index 9042b7f9f..4003fb5ad 100644 --- a/port/PyAssimp/pyassimp/helper.py +++ b/port/PyAssimp/pyassimp/helper.py @@ -192,9 +192,9 @@ def try_load_functions(library_path, dll): # library found! from .structs import Scene, ExportDataBlob - load.restype = ctype.POINTER(Scene) - load_mem.restype = ctype.POINTER(Scene) - export2blob.restype = ctype.POINTER(ExportDataBlob) + load.restype = ctypes.POINTER(Scene) + load_mem.restype = ctypes.POINTER(Scene) + export2blob.restype = ctypes.POINTER(ExportDataBlob) return (library_path, load, load_mem, export, export2blob, release, dll) def search_library(): @@ -274,6 +274,8 @@ def hasattr_silent(object, name): """ try: + if not object: + return False return hasattr(object, name) except AttributeError: return False diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 1d25a7730..28aeac65a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -37,7 +37,7 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # #---------------------------------------------------------------------- -cmake_minimum_required( VERSION 2.6 ) +cmake_minimum_required( VERSION 3.0 ) INCLUDE_DIRECTORIES( ${Assimp_SOURCE_DIR}/contrib/gtest/include @@ -126,7 +126,7 @@ SET( IMPORTERS unit/ImportExport/utOFFImportExport.cpp unit/ImportExport/utNFFImportExport.cpp unit/ImportExport/utXGLImportExport.cpp - unit/ImportExport/utJTImporter.cpp +# unit/ImportExport/utJTImporter.cpp ) SET( MATERIAL @@ -162,6 +162,7 @@ SET( POST_PROCESSES unit/utTargetAnimation.cpp unit/utSortByPType.cpp unit/utSceneCombiner.cpp + unit/utGenBoundingBoxesProcess.cpp ) SOURCE_GROUP( UnitTests\\Compiler FILES unit/CCompilerTest.c ) @@ -175,7 +176,7 @@ add_executable( unit ../contrib/gtest/src/gtest-all.cc unit/CCompilerTest.c unit/Main.cpp - ../code/Version.cpp + ../code/Common/Version.cpp ${COMMON} ${IMPORTERS} ${MATERIAL} diff --git a/test/models/FBX/cubes_nonames.fbx b/test/models/FBX/cubes_nonames.fbx new file mode 100644 index 000000000..810657aff --- /dev/null +++ b/test/models/FBX/cubes_nonames.fbx @@ -0,0 +1,852 @@ +; FBX 7.5.0 project file +; ---------------------------------------------------- + +FBXHeaderExtension: { + FBXHeaderVersion: 1003 + FBXVersion: 7500 + CreationTimeStamp: { + Version: 1000 + Year: 2019 + Month: 1 + Day: 7 + Hour: 16 + Minute: 17 + Second: 31 + Millisecond: 730 + } + Creator: "FBX SDK/FBX Plugins version 2018.1.1" + SceneInfo: "SceneInfo::GlobalInfo", "UserData" { + Type: "UserData" + Version: 100 + MetaData: { + Version: 100 + Title: "" + Subject: "" + Author: "" + Keywords: "" + Revision: "" + Comment: "" + } + Properties70: { + P: "DocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\cubes_noname.fbx" + P: "SrcDocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\cubes_noname.fbx" + P: "Original", "Compound", "", "" + P: "Original|ApplicationVendor", "KString", "", "", "Autodesk" + P: "Original|ApplicationName", "KString", "", "", "Maya" + P: "Original|ApplicationVersion", "KString", "", "", "201800" + P: "Original|DateTime_GMT", "DateTime", "", "", "07/01/2019 16:17:31.730" + P: "Original|FileName", "KString", "", "", "U:\Some\Absolute\Path\cubes_noname.fbx" + P: "LastSaved", "Compound", "", "" + P: "LastSaved|ApplicationVendor", "KString", "", "", "Autodesk" + P: "LastSaved|ApplicationName", "KString", "", "", "Maya" + P: "LastSaved|ApplicationVersion", "KString", "", "", "201800" + P: "LastSaved|DateTime_GMT", "DateTime", "", "", "07/01/2019 16:17:31.730" + P: "Original|ApplicationActiveProject", "KString", "", "", "U:\Some\Absolute\Path" + } + } +} +GlobalSettings: { + Version: 1000 + Properties70: { + P: "UpAxis", "int", "Integer", "",1 + P: "UpAxisSign", "int", "Integer", "",1 + P: "FrontAxis", "int", "Integer", "",2 + P: "FrontAxisSign", "int", "Integer", "",1 + P: "CoordAxis", "int", "Integer", "",0 + P: "CoordAxisSign", "int", "Integer", "",1 + P: "OriginalUpAxis", "int", "Integer", "",1 + P: "OriginalUpAxisSign", "int", "Integer", "",1 + P: "UnitScaleFactor", "double", "Number", "",1 + P: "OriginalUnitScaleFactor", "double", "Number", "",1 + P: "AmbientColor", "ColorRGB", "Color", "",0,0,0 + P: "DefaultCamera", "KString", "", "", "Producer Perspective" + P: "TimeMode", "enum", "", "",11 + P: "TimeProtocol", "enum", "", "",2 + P: "SnapOnFrameMode", "enum", "", "",0 + P: "TimeSpanStart", "KTime", "Time", "",1924423250 + P: "TimeSpanStop", "KTime", "Time", "",384884650000 + P: "CustomFrameRate", "double", "Number", "",-1 + P: "TimeMarker", "Compound", "", "" + P: "CurrentTimeMarker", "int", "Integer", "",-1 + } +} + +; Documents Description +;------------------------------------------------------------------ + +Documents: { + Count: 1 + Document: 2359325563280, "", "Scene" { + Properties70: { + P: "SourceObject", "object", "", "" + P: "ActiveAnimStackName", "KString", "", "", "Take 001" + } + RootNode: 0 + } +} + +; Document References +;------------------------------------------------------------------ + +References: { +} + +; Object definitions +;------------------------------------------------------------------ + +Definitions: { + Version: 100 + Count: 13 + ObjectType: "GlobalSettings" { + Count: 1 + } + ObjectType: "AnimationStack" { + Count: 1 + PropertyTemplate: "FbxAnimStack" { + Properties70: { + P: "Description", "KString", "", "", "" + P: "LocalStart", "KTime", "Time", "",0 + P: "LocalStop", "KTime", "Time", "",0 + P: "ReferenceStart", "KTime", "Time", "",0 + P: "ReferenceStop", "KTime", "Time", "",0 + } + } + } + ObjectType: "AnimationLayer" { + Count: 1 + PropertyTemplate: "FbxAnimLayer" { + Properties70: { + P: "Weight", "Number", "", "A",100 + P: "Mute", "bool", "", "",0 + P: "Solo", "bool", "", "",0 + P: "Lock", "bool", "", "",0 + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BlendMode", "enum", "", "",0 + P: "RotationAccumulationMode", "enum", "", "",0 + P: "ScaleAccumulationMode", "enum", "", "",0 + P: "BlendModeBypass", "ULongLong", "", "",0 + } + } + } + ObjectType: "Geometry" { + Count: 4 + PropertyTemplate: "FbxMesh" { + Properties70: { + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BBoxMin", "Vector3D", "Vector", "",0,0,0 + P: "BBoxMax", "Vector3D", "Vector", "",0,0,0 + P: "Primary Visibility", "bool", "", "",1 + P: "Casts Shadows", "bool", "", "",1 + P: "Receive Shadows", "bool", "", "",1 + } + } + } + ObjectType: "Material" { + Count: 2 + PropertyTemplate: "FbxSurfaceLambert" { + Properties70: { + P: "ShadingModel", "KString", "", "", "Lambert" + P: "MultiLayer", "bool", "", "",0 + P: "EmissiveColor", "Color", "", "A",0,0,0 + P: "EmissiveFactor", "Number", "", "A",1 + P: "AmbientColor", "Color", "", "A",0.2,0.2,0.2 + P: "AmbientFactor", "Number", "", "A",1 + P: "DiffuseColor", "Color", "", "A",0.8,0.8,0.8 + P: "DiffuseFactor", "Number", "", "A",1 + P: "Bump", "Vector3D", "Vector", "",0,0,0 + P: "NormalMap", "Vector3D", "Vector", "",0,0,0 + P: "BumpFactor", "double", "Number", "",1 + P: "TransparentColor", "Color", "", "A",0,0,0 + P: "TransparencyFactor", "Number", "", "A",0 + P: "DisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "DisplacementFactor", "double", "Number", "",1 + P: "VectorDisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "VectorDisplacementFactor", "double", "Number", "",1 + } + } + } + ObjectType: "Model" { + Count: 4 + PropertyTemplate: "FbxNode" { + Properties70: { + P: "QuaternionInterpolate", "enum", "", "",0 + P: "RotationOffset", "Vector3D", "Vector", "",0,0,0 + P: "RotationPivot", "Vector3D", "Vector", "",0,0,0 + P: "ScalingOffset", "Vector3D", "Vector", "",0,0,0 + P: "ScalingPivot", "Vector3D", "Vector", "",0,0,0 + P: "TranslationActive", "bool", "", "",0 + P: "TranslationMin", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMax", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMinX", "bool", "", "",0 + P: "TranslationMinY", "bool", "", "",0 + P: "TranslationMinZ", "bool", "", "",0 + P: "TranslationMaxX", "bool", "", "",0 + P: "TranslationMaxY", "bool", "", "",0 + P: "TranslationMaxZ", "bool", "", "",0 + P: "RotationOrder", "enum", "", "",0 + P: "RotationSpaceForLimitOnly", "bool", "", "",0 + P: "RotationStiffnessX", "double", "Number", "",0 + P: "RotationStiffnessY", "double", "Number", "",0 + P: "RotationStiffnessZ", "double", "Number", "",0 + P: "AxisLen", "double", "Number", "",10 + P: "PreRotation", "Vector3D", "Vector", "",0,0,0 + P: "PostRotation", "Vector3D", "Vector", "",0,0,0 + P: "RotationActive", "bool", "", "",0 + P: "RotationMin", "Vector3D", "Vector", "",0,0,0 + P: "RotationMax", "Vector3D", "Vector", "",0,0,0 + P: "RotationMinX", "bool", "", "",0 + P: "RotationMinY", "bool", "", "",0 + P: "RotationMinZ", "bool", "", "",0 + P: "RotationMaxX", "bool", "", "",0 + P: "RotationMaxY", "bool", "", "",0 + P: "RotationMaxZ", "bool", "", "",0 + P: "InheritType", "enum", "", "",0 + P: "ScalingActive", "bool", "", "",0 + P: "ScalingMin", "Vector3D", "Vector", "",0,0,0 + P: "ScalingMax", "Vector3D", "Vector", "",1,1,1 + P: "ScalingMinX", "bool", "", "",0 + P: "ScalingMinY", "bool", "", "",0 + P: "ScalingMinZ", "bool", "", "",0 + P: "ScalingMaxX", "bool", "", "",0 + P: "ScalingMaxY", "bool", "", "",0 + P: "ScalingMaxZ", "bool", "", "",0 + P: "GeometricTranslation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricRotation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricScaling", "Vector3D", "Vector", "",1,1,1 + P: "MinDampRangeX", "double", "Number", "",0 + P: "MinDampRangeY", "double", "Number", "",0 + P: "MinDampRangeZ", "double", "Number", "",0 + P: "MaxDampRangeX", "double", "Number", "",0 + P: "MaxDampRangeY", "double", "Number", "",0 + P: "MaxDampRangeZ", "double", "Number", "",0 + P: "MinDampStrengthX", "double", "Number", "",0 + P: "MinDampStrengthY", "double", "Number", "",0 + P: "MinDampStrengthZ", "double", "Number", "",0 + P: "MaxDampStrengthX", "double", "Number", "",0 + P: "MaxDampStrengthY", "double", "Number", "",0 + P: "MaxDampStrengthZ", "double", "Number", "",0 + P: "PreferedAngleX", "double", "Number", "",0 + P: "PreferedAngleY", "double", "Number", "",0 + P: "PreferedAngleZ", "double", "Number", "",0 + P: "LookAtProperty", "object", "", "" + P: "UpVectorProperty", "object", "", "" + P: "Show", "bool", "", "",1 + P: "NegativePercentShapeSupport", "bool", "", "",1 + P: "DefaultAttributeIndex", "int", "Integer", "",-1 + P: "Freeze", "bool", "", "",0 + P: "LODBox", "bool", "", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",0,0,0 + P: "Lcl Rotation", "Lcl Rotation", "", "A",0,0,0 + P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1 + P: "Visibility", "Visibility", "", "A",1 + P: "Visibility Inheritance", "Visibility Inheritance", "", "",1 + } + } + } +} + +; Object properties +;------------------------------------------------------------------ + +Objects: { + Geometry: 2358377979296, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 2358377961872, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 2358377982464, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 2358377979824, "Geometry::", "Mesh" { + Vertices: *588 { + a: -0.499999970197678,-0.5,0.5,0.500000059604645,-0.5,0.5,-0.499999970197678,0.5,0.5,0.500000059604645,0.5,0.5,-0.499999970197678,0.5,-0.49999988079071,0.500000059604645,0.5,-0.49999988079071,-0.499999970197678,-0.5,-0.49999988079071,0.500000059604645,-0.5,-0.49999988079071,0,0,0.5,0,-0.5,0.5,0.500000059604645,0,0.5,0,0.5,0.5,-0.499999970197678,0,0.5,0,0.5,1.19209289550781e-07,0.500000059604645,0.5,1.19209289550781e-07,0,0.5,-0.49999988079071,-0.499999970197678,0.5,1.19209289550781e-07,0,0,-0.49999988079071,0.500000059604645,0,-0.49999988079071,0,-0.5,-0.49999988079071,-0.499999970197678,0,-0.49999988079071,0,-0.5,1.19209289550781e-07,0.500000059604645,-0.5,1.19209289550781e-07,-0.499999970197678,-0.5,1.19209289550781e-07,0.500000059604645,0,1.19209289550781e-07,-0.499999970197678,0,1.19209289550781e-07,-0.25,-0.25,0.5,-0.499999970197678,-0.25,0.5,-0.25,-0.5,0.5,0,-0.25,0.5,-0.25,0,0.5,-0.25,0.5,0.25,-0.499999970197678,0.5,0.25,-0.25,0.5,0.5,0,0.5,0.25,-0.25,0.5,1.19209289550781e-07,-0.25,0.25,-0.49999988079071,-0.499999970197678,0.25,-0.49999988079071,-0.25,0.5,-0.49999988079071,0,0.25,-0.49999988079071,-0.25,0,-0.49999988079071,-0.25,-0.5,-0.24999988079071,-0.499999970197678,-0.5,-0.24999988079071,-0.25,-0.5,-0.49999988079071,0,-0.5,-0.24999988079071,-0.25,-0.5,1.19209289550781e-07,0.500000059604645,-0.25,0.25,0.500000059604645,-0.25,0.5,0.500000059604645,-0.5,0.25,0.500000059604645,-0.25,1.19209289550781e-07,0.500000059604645,0,0.25,-0.499999970197678,-0.25,-0.24999988079071,-0.499999970197678,-0.25,-0.49999988079071,-0.499999970197678,-0.25,1.19209289550781e-07,-0.499999970197678,0,-0.24999988079071,0.250000059604645,-0.25,0.5,0.250000059604645,-0.5,0.5,0.250000059604645,0,0.5,0.250000059604645,0.25,0.5,0.500000059604645,0.25,0.5,0.250000059604645,0.5,0.5,0,0.25,0.5,-0.25,0.25,0.5,-0.499999970197678,0.25,0.5,0.250000059604645,0.5,0.25,0.500000059604645,0.5,0.25,0.250000059604645,0.5,1.19209289550781e-07,0.250000059604645,0.5,-0.24999988079071,0.500000059604645,0.5,-0.24999988079071,0.250000059604645,0.5,-0.49999988079071, +0,0.5,-0.24999988079071,-0.25,0.5,-0.24999988079071,-0.499999970197678,0.5,-0.24999988079071,0.250000059604645,0.25,-0.49999988079071,0.500000059604645,0.25,-0.49999988079071,0.250000059604645,0,-0.49999988079071,0.250000059604645,-0.25,-0.49999988079071,0.500000059604645,-0.25,-0.49999988079071,0.250000059604645,-0.5,-0.49999988079071,0,-0.25,-0.49999988079071,-0.25,-0.25,-0.49999988079071,0.250000059604645,-0.5,-0.24999988079071,0.500000059604645,-0.5,-0.24999988079071,0.250000059604645,-0.5,1.19209289550781e-07,0.250000059604645,-0.5,0.25,0,-0.5,0.25,-0.25,-0.5,0.25,-0.499999970197678,-0.5,0.25,0.500000059604645,-0.25,-0.24999988079071,0.500000059604645,0,-0.24999988079071,0.500000059604645,0.25,-0.24999988079071,0.500000059604645,0.25,1.19209289550781e-07,0.500000059604645,0.25,0.25,-0.499999970197678,-0.25,0.25,-0.499999970197678,0,0.25,-0.499999970197678,0.25,0.25,-0.499999970197678,0.25,1.19209289550781e-07,-0.499999970197678,0.25,-0.24999988079071,-0.594913899898529,0,0.594913899898529,-0.152911216020584,0,0.714658200740814,-0.594913899898529,-0.152911216020584,0.594913899898529,-0.152911216020584,-0.152911216020584,0.714658200740814,-0.594913899898529,0.594913899898529,7.29137497046395e-08,-0.152911216020584,0.714658200740814,7.29137497046395e-08,-0.594913899898529,0.594913899898529,0.152911216020584,-0.152911216020584,0.714658200740814,0.152911216020584,-0.594913899898529,0,-0.594913899898529,-0.152911216020584,0,-0.714658200740814,-0.594913899898529,0.152911216020584,-0.594913899898529,-0.152911216020584,0.152911216020584,-0.714658200740814,-0.594913899898529,-0.594913899898529,7.29137497046395e-08,-0.152911216020584,-0.714658200740814,7.29137497046395e-08,-0.594913899898529,-0.594913899898529,-0.152911216020584,-0.152911216020584,-0.714658200740814,-0.152911216020584,0.594913899898529,0,0.594913899898529,0.714658200740814,0,0.152911216020584,0.594913899898529,-0.152911216020584,0.594913899898529,0.714658200740814,-0.152911216020584,0.152911216020584,-0.714658200740814,0,-0.152911216020584,-0.594913899898529,-0.152911216020584,-0.594913899898529, +-0.714658200740814,-0.152911216020584,-0.152911216020584,8.62321627254444e-17,-0.594913899898529,0.594913899898529,8.62321627254444e-17,-0.152911216020584,0.714658200740814,0.152911230921745,-0.594913899898529,0.594913899898529,0.152911230921745,-0.152911216020584,0.714658200740814,0.152911230921745,0,0.714658200740814,0.594913899898529,0.152911216020584,0.594913899898529,0.152911230921745,0.152911216020584,0.714658200740814,8.62321627254444e-17,0.594913899898529,0.594913899898529,8.62321627254444e-17,0.152911216020584,0.714658200740814,-0.152911216020584,0.594913899898529,0.594913899898529,-0.152911216020584,0.152911216020584,0.714658200740814,8.62321627254444e-17,0.714658200740814,0.152911216020584,0.152911230921745,0.594913899898529,0.594913899898529,0.152911230921745,0.714658200740814,0.152911216020584,0.594913899898529,0.594913899898529,7.29137497046395e-08,0.152911230921745,0.714658200740814,7.29137497046395e-08,0.594913899898529,0.594913899898529,-0.152911216020584,0.152911230921745,0.714658200740814,-0.152911216020584,8.62321627254444e-17,0.594913899898529,-0.594913899898529,8.62321627254444e-17,0.714658200740814,-0.152911216020584,-0.152911216020584,0.594913899898529,-0.594913899898529,-0.152911216020584,0.714658200740814,-0.152911216020584,8.62321627254444e-17,0.152911216020584,-0.714658200740814,0.152911230921745,0.594913899898529,-0.594913899898529,0.152911230921745,0.152911216020584,-0.714658200740814,0.594913899898529,0,-0.594913899898529,0.152911230921745,0,-0.714658200740814,0.594913899898529,-0.152911216020584,-0.594913899898529,0.152911230921745,-0.152911216020584,-0.714658200740814,8.62321627254444e-17,-0.594913899898529,-0.594913899898529,8.62321627254444e-17,-0.152911216020584,-0.714658200740814,-0.152911216020584,-0.594913899898529,-0.594913899898529,-0.152911216020584,-0.152911216020584,-0.714658200740814,8.62321627254444e-17,-0.714658200740814,-0.152911216020584,0.152911230921745,-0.594913899898529,-0.594913899898529,0.152911230921745,-0.714658200740814,-0.152911216020584,0.594913899898529,-0.594913899898529,7.29137497046395e-08, +0.152911230921745,-0.714658200740814,7.29137497046395e-08,0.594913899898529,-0.594913899898529,0.152911216020584,0.152911230921745,-0.714658200740814,0.152911216020584,8.62321627254444e-17,-0.714658200740814,0.152911216020584,-0.152911216020584,-0.594913899898529,0.594913899898529,-0.152911216020584,-0.714658200740814,0.152911216020584,0.714658200740814,-0.152911216020584,7.29137497046395e-08,0.594913899898529,-0.594913899898529,-0.152911216020584,0.714658200740814,-0.152911216020584,-0.152911216020584,0.714658200740814,0,-0.152911216020584,0.594913899898529,0.152911216020584,-0.594913899898529,0.714658200740814,0.152911216020584,-0.152911216020584,0.714658200740814,0.152911216020584,7.29137497046395e-08,0.594913899898529,0.594913899898529,0.152911216020584,0.714658200740814,0.152911216020584,0.152911216020584,-0.714658200740814,-0.152911216020584,7.29137497046395e-08,-0.594913899898529,-0.594913899898529,0.152911216020584,-0.714658200740814,-0.152911216020584,0.152911216020584,-0.714658200740814,0,0.152911216020584,-0.594913899898529,0.152911216020584,0.594913899898529,-0.714658200740814,0.152911216020584,0.152911216020584,-0.714658200740814,0.152911216020584,7.29137497046395e-08,-0.594913899898529,0.594913899898529,-0.152911216020584,-0.714658200740814,0.152911216020584,-0.152911216020584,-0.541863918304443,-0.541864037513733,0.541863918304443,8.62321627254444e-17,0,0.714658200740814,-0.541863918304443,0.541863918304443,0.541863918304443,8.62321627254444e-17,0.714658200740814,7.29137497046395e-08,-0.541863918304443,0.541863918304443,-0.541863799095154,8.62321627254444e-17,0,-0.714658200740814,-0.541863918304443,-0.541864037513733,-0.541863799095154,8.62321627254444e-17,-0.714658200740814,7.29137497046395e-08,0.541863977909088,-0.541864037513733,0.541863918304443,0.714658200740814,0,7.29137497046395e-08,-0.714658200740814,0,7.29137497046395e-08,0.541863977909088,0.541863918304443,0.541863918304443,0.541863977909088,0.541863918304443,-0.541863799095154,0.541863977909088,-0.541864037513733,-0.541863799095154 + } + PolygonVertexIndex: *768 { + a: 99,98,100,-102,103,102,104,-106,107,106,108,-110,111,110,112,-114,115,114,116,-118,118,106,119,-121,122,121,123,-125,125,114,126,-128,129,128,130,-132,132,128,133,-135,136,135,137,-139,140,139,141,-143,143,139,144,-146,147,146,148,-150,151,150,152,-154,154,150,155,-157,158,157,159,-161,161,121,162,-164,164,157,165,-167,167,146,168,-170,170,135,171,-173,173,110,174,-176,176,98,177,-179,179,102,180,-182,100,182,162,-102,162,121,122,-102,122,183,99,-102,104,184,130,-106,130,128,132,-106,132,185,103,-106,108,186,141,-110,141,139,143,-110,143,187,107,-110,112,188,152,-114,152,150,154,-114,154,189,111,-114,116,190,159,-118,159,157,164,-118,164,191,115,-118,119,188,112,-121,112,110,173,-121,173,192,118,-121,123,190,116,-125,116,114,125,-125,125,183,122,-125,126,193,133,-128,133,128,129,-128,129,183,125,-128,130,184,177,-132,177,98,99,-132,99,183,129,-132,133,193,171,-135,171,135,136,-135,136,185,132,-135,137,194,144,-139,144,139,140,-139,140,185,136,-139,141,186,180,-143,180,102,103,-143,103,185,140,-143,144,194,168,-146,168,146,147,-146,147,187,143,-146,148,195,155,-150,155,150,151,-150,151,187,147,-150,152,188,119,-154,119,106,107,-154,107,187,151,-154,155,195,165,-157,165,157,158,-157,158,189,154,-157,159,190,123,-161,123,121,161,-161,161,189,158,-161,162,182,174,-164,174,110,111,-164,111,189,161,-164,165,195,148,-167,148,146,167,-167,167,191,164,-167,168,194,137,-170,137,135,170,-170,170,191,167,-170,171,193,126,-173,126,114,115,-173,115,191,170,-173,174,182,100,-176,100,98,176,-176,176,192,173,-176,177,184,104,-179,104,102,179,-179,179,192,176,-179,180,186,108,-182,108,106,118,-182,118,192,179,-182,30,26,27,-13,35,31,32,-17,40,36,37,-21,45,41,42,-24,50,46,47,-11,54,51,52,-21,29,55,56,-10,57,58,59,-11,61,62,33,-12,34,64,60,-12,66,67,68,-15,70,71,38,-16,39,73,69,-16,75,76,77,-19,79,80,43,-20,44,81,78,-20,83,84,48,-23,85,86,28,-10,49,88,82,-23,89,90,74,-19,91,92,65,-15,53,93,87,-24,94,95,63,-13,96,97,72,-17,27,26,28,-1,28,26,29,-10,29,26,30,-9,32,31,33,-3,33,31,34,-12,34,31,35,-14,37,36,38,-5,38,36,39, +-16,39,36,40,-18,42,41,43,-7,43,41,44,-20,44,41,45,-22,47,46,48,-2,48,46,49,-23,49,46,50,-25,52,51,42,-7,42,51,53,-24,53,51,54,-26,56,55,47,-2,47,55,57,-11,57,55,29,-9,59,58,60,-4,60,58,61,-12,61,58,57,-9,33,62,63,-3,63,62,30,-13,30,62,61,-9,60,64,65,-4,65,64,66,-15,66,64,34,-14,68,67,69,-6,69,67,70,-16,70,67,66,-14,38,71,72,-5,72,71,35,-17,35,71,70,-14,69,73,74,-6,74,73,75,-19,75,73,39,-18,77,76,78,-8,78,76,79,-20,79,76,75,-18,43,80,52,-7,52,80,40,-21,40,80,79,-18,78,81,82,-8,82,81,83,-23,83,81,44,-22,48,84,56,-2,56,84,85,-10,85,84,83,-22,28,86,87,-1,87,86,45,-24,45,86,85,-22,82,88,77,-8,77,88,89,-19,89,88,49,-25,74,90,68,-6,68,90,91,-15,91,90,89,-25,65,92,59,-4,59,92,50,-11,50,92,91,-25,87,93,27,-1,27,93,94,-13,94,93,53,-26,63,95,32,-3,32,95,96,-17,96,95,94,-26,72,97,37,-5,37,97,54,-21,54,97,96,-26 + } + Edges: *384 { + a: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,102,104,105,108,109,110,114,116,117,120,121,122,126,128,129,132,133,134,138,140,141,144,145,146,150,152,153,156,158,162,164,165,168,170,174,176,180,181,182,186,188,193,194,198,205,206,210,212,216,217,218,222,224,229,230,234,241,242,246,248,252,253,254,258,260,266,270,277,278,282,284,290,294,296,301,302,306,314,318,320,326,330,332,338,342,350,354,356,362,366,368,374,378,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,481,482,483,485,490,491,493,494,495,497,502,503,505,506,507,509,514,515,517,518,519,521,526,527,529,530,531,533,538,539,541,543,545,550,551,553,555,557,563,565,566,567,569,575,577,578,581,589,590,593,599,601,602,603,605,611,613,614,617,625,626,629,635,637,638,639,641,647,649,653,661,662,665,671,673,677,683,685,686,689,697,701,707,709,713,719,721,725,733,737,743,745,749,755,757,761 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *2304 { + a: -0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.26148721575737,0.965207040309906,0,-0.26148721575737,0.965207040309906,0,-0.26148721575737,0.965207040309906,0,-0.26148721575737,0.965207040309906,0,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0.261487126350403,0,-0.965206980705261, +0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0.26148721575737,-0.965207040309906,0,0.26148721575737,-0.965207040309906,0,0.26148721575737,-0.965207040309906,0,0.26148721575737,-0.965207040309906,0,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.211917281150818,-0.211917445063591,0.954034626483917,0,0,1,-0.211917281150818,-0.21191743016243,0.954034626483917,-0.211917266249657,-0.211917445063591,0.954034626483917,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,-0.211917445063591,0.954034626483917,0.211917281150818, +0,1,0,-0.211917445063591,0.954034626483917,0.211917281150818,-0.211917445063591,0.954034626483917,0.211917266249657,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,1,0,0,1,0,0,1,0,0,1,0,-0.211917623877525,0.211917608976364,-0.954034626483917,0,0,-1,-0.211917623877525,0.211917608976364,-0.954034626483917,-0.211917623877525,0.211917594075203,-0.954034626483917,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.211917355656624,-0.954034745693207,-0.211917355656624,0,-1,0,-0.211917325854301,-0.954034686088562,-0.211917325854301,-0.211917355656624,-0.954034686088562,-0.211917355656624,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.954034745693207,-0.211917281150818,0.211917340755463,1,0,0,0.954034745693207,-0.211917281150818,0.211917370557785,0.954034626483917,-0.211917236447334,0.211917296051979,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,1,0,0,1,0,0,1,0,0,1,0,0,-0.954034686088562,-0.211917355656624,-0.211917459964752,-1,0,0,-0.954034626483917,-0.211917325854301,-0.211917445063591,-0.954034686088562,-0.211917355656624,-0.211917474865913,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0.211917281150818,-0.211917400360107,0.954034626483917,0,0,1,0.211917266249657,-0.211917415261269,0.954034626483917,0.211917266249657,-0.211917415261269,0.954034626483917,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261, +0,0,1,0,0,1,0,0,1,0,0,1,0.211917296051979,0.211917415261269,0.954034626483917,0,0,1,0.211917296051979,0.211917415261269,0.954034626483917,0.211917281150818,0.211917415261269,0.954034626483917,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,-0.211917281150818,0.211917445063591,0.954034626483917,0,0,1,-0.211917281150818,0.211917445063591,0.954034626483917,-0.211917266249657,0.211917445063591,0.954034626483917,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0.211917445063591,0.954034626483917,0.211917445063591,0,1,0,0.211917445063591,0.954034686088562,0.211917445063591,0.211917445063591,0.954034626483917,0.211917445063591,0.26148721575737,0.965207040309906,0,0.26148721575737,0.965207040309906,0,0.26148721575737,0.965207040309906,0,0.26148721575737,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,0,0.211917445063591,0.954034626483917,-0.211917489767075,0,1,0,0.211917459964752,0.954034686088562,-0.211917519569397,0.211917474865913,0.954034686088562,-0.211917504668236,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,1,0,0,1,0,0,1,0,0,1,0,-0.211917459964752,0.954034686088562,-0.211917340755463,0,1,0,-0.211917445063591,0.954034626483917,-0.21191731095314,-0.211917489767075,0.954034686088562,-0.211917355656624,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,0,0.211917638778687,0.211917608976364,-0.954034626483917,0,0,-1,0.211917608976364,0.211917564272881,-0.954034566879272,0.211917623877525,0.211917608976364,-0.954034626483917,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261, +0.261487126350403,0,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0.211917608976364,-0.211917564272881,-0.954034626483917,0,0,-1,0.211917623877525,-0.211917579174042,-0.954034626483917,0.211917623877525,-0.211917549371719,-0.954034626483917,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.211917623877525,-0.211917579174042,-0.954034626483917,0,0,-1,-0.211917579174042,-0.211917534470558,-0.954034566879272,-0.211917623877525,-0.211917549371719,-0.954034626483917,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0.211917340755463,-0.954034686088562,-0.211917519569397,0,-1,0,0.211917325854301,-0.954034626483917,-0.211917489767075,0.211917325854301,-0.954034686088562,-0.211917489767075,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.211917281150818,-0.954034626483917,0.211917445063591,0,-1,0,0.211917296051979,-0.954034626483917,0.211917445063591,0.211917266249657,-0.954034626483917,0.211917445063591,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.211917325854301,-0.954034745693207,0.211917325854301,0,-1,0,-0.211917325854301,-0.954034745693207,0.211917325854301,-0.211917281150818,-0.954034686088562,0.211917281150818,-0.26148721575737,-0.965207040309906,0,-0.26148721575737,-0.965207040309906,0,-0.26148721575737,-0.965207040309906,0,-0.26148721575737,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.954034626483917,-0.211917325854301,-0.211917400360107,1,0,0,0.954034686088562,-0.211917340755463,-0.211917400360107,0.954034686088562,-0.211917355656624,-0.21191743016243,0.965206980705261,0,-0.261487185955048, +0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,1,0,0,1,0,0,1,0,0,1,0,0,0.954034686088562,0.211917370557785,-0.211917489767075,1,0,0,0.954034686088562,0.211917355656624,-0.211917445063591,0.954034626483917,0.211917355656624,-0.211917445063591,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,1,0,0,1,0,0,1,0,0,1,0,0,0.954034626483917,0.211917296051979,0.211917385458946,1,0,0,0.954034626483917,0.211917296051979,0.211917385458946,0.954034745693207,0.211917296051979,0.211917385458946,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,1,0,0,1,0,0,1,0,0,1,0,0,-0.954034626483917,-0.211917251348495,0.211917400360107,-1,0,0,-0.954034626483917,-0.211917266249657,0.211917400360107,-0.954034626483917,-0.211917251348495,0.211917400360107,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.954034626483917,0.211917281150818,0.211917445063591,-1,0,0,-0.954034626483917,0.211917281150818,0.211917445063591,-0.954034626483917,0.211917266249657,0.211917445063591,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.954034686088562,0.211917385458946,-0.211917549371719,-1,0,0,-0.954034686088562,0.211917370557785,-0.211917534470558,-0.954034626483917,0.211917355656624,-0.211917504668236,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0, +1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0, +-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0 + } + NormalsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *2304 { + a: 0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0, +0,1,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,-0.0554696954786777,0.977241098880768,0.204750895500183,0.0677256807684898,0.997704029083252,-0,0.0995207726955414,0.966452240943909,0.236782029271126,0.022095151245594,0.974918127059937,0.221464186906815,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0554696545004845,0.204750746488571,-0.977241158485413,0.0677258297801018,0,-0.997703969478607,0.0995210781693459,0.23678195476532,-0.966452240943909,0.0220953319221735,0.221464082598686,-0.974918246269226,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0554697290062904,-0.977241039276123,-0.204751029610634,0.0677258297801018,-0.997703969478607,0,0.0995209515094757,-0.966452121734619,-0.236782252788544,0.0220952276140451,-0.974918127059937,-0.221464350819588,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,-0.0554696619510651,-0.204750776290894,0.977241098880768,0.0677259787917137,0,0.997703969478607,0.0995214134454727,-0.236782014369965,0.966452121734619,0.0220954976975918,-0.221464157104492,0.974918186664581,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0.20475073158741,0.977241218090057,0.0554696507751942,0,0.997704029083252,-0.0677256807684898,0.236781880259514,0.966452300548553,-0.0995208472013474,0.221463993191719,0.974918186664581,-0.0220952145755291,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0, +-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.204750791192055,0.977241098880768,-0.0554696619510651,0,0.997704029083252,0.0677257031202316,-0.236781939864159,0.966452240943909,0.099520817399025,-0.221464112401009,0.974918246269226,0.022095188498497,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0,-0.099520780146122,0.966452240943909,0.236781999468803,-0.0677256733179092,0.997704029083252,0,0.0554696880280972,0.977241098880768,0.204750865697861,-0.022095151245594,0.974918127059937,0.221464157104492,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0554696880280972,0.977241098880768,-0.204750865697861,0.0677258223295212,0.997703969478607,-0,0.0995210558176041,0.966452181339264,-0.236782059073448,0.0220952890813351,0.974918246269226,-0.221464201807976,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0995210707187653,0.966452240943909,-0.236782118678093,-0.0677258297801018,0.997703969478607,0,0.0554696954786777,0.977241098880768,-0.204750895500183,-0.0220952928066254,0.974918186664581,-0.221464231610298,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0995210558176041,0.236782118678093,-0.966452240943909,-0.0677258223295212,0,-0.997703969478607,0.0554696880280972,0.204750880599022,-0.977241098880768,-0.0220952853560448,0.221464216709137,-0.974918127059937,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0554697066545486,-0.204750955104828,-0.977241158485413,0.0677259713411331,0,-0.997703969478607,0.0995213389396667,-0.236782237887383,-0.966452181339264,0.0220954176038504,-0.221464291214943,-0.974918127059937,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0995213687419891,-0.236782059073448,-0.966452181339264, +-0.0677259787917137,0,-0.997703969478607,0.0554696545004845,-0.204750776290894,-0.977241158485413,-0.0220954604446888,-0.221464172005653,-0.974918246269226,0,0,-1,0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0995209366083145,-0.966452121734619,-0.236782252788544,-0.0677258223295212,-0.997703969478607,-0,0.0554697290062904,-0.977241098880768,-0.204751014709473,-0.0220952201634645,-0.974918127059937,-0.221464365720749,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,-0.0554697252810001,-0.977241158485413,0.204751014709473,0.0677256733179092,-0.997704029083252,0,0.099520668387413,-0.966452181339264,0.236782178282738,0.0220950860530138,-0.974918127059937,0.221464276313782,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-1,0,0,-1,0,0,-1,-0,0,-1,0,-0.0995206832885742,-0.966452181339264,0.236782178282738,-0.0677256807684898,-0.997704029083252,-0,0.0554697178304195,-0.977241098880768,0.20475098490715,-0.0220950935035944,-0.974918127059937,0.221464276313782,0,-1,-0,0,-1,-0,-0,-1,0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.0995213836431503,-0.23678220808506,0.966452121734619,-0.0677259713411331,0,0.997703969478607,0.0554697066545486,-0.204750940203667,0.977241098880768,-0.0220954623073339,-0.221464291214943,0.974918186664581,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0.0554696954786777,0.204750895500183,0.977241098880768,0.0677258223295212,0,0.997703969478607,0.0995211154222488,0.236782103776932,0.966452181339264,0.0220953226089478,0.221464246511459,0.974918186664581,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,-0.0995211452245712,0.23678195476532,0.966452181339264,-0.0677258297801018,0,0.997703969478607,0.0554696656763554,0.204750776290894,0.977241218090057,-0.022095363587141,0.221464082598686,0.974918246269226,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0.236781939864159,0.966452240943909,0.0995208621025085, +-0,0.997704029083252,0.0677257031202316,0.204750806093216,0.977241158485413,-0.0554696656763554,0.221464112401009,0.974918186664581,0.0220951996743679,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.204750806093216,0.977241098880768,0.0554696694016457,0,0.997703969478607,-0.0677258521318436,-0.236782044172287,0.966452240943909,-0.0995211452245712,-0.221464172005653,0.974918246269226,-0.0220953542739153,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,0,1,-0,-0,1,0,-0,1,0,-0,1,0,-0.236781984567642,0.966452300548553,0.09952113032341,-0,0.997703969478607,0.0677258297801018,-0.204750761389732,0.977241158485413,-0.0554696582257748,-0.221464067697525,0.974918246269226,0.0220953486859798,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,-0,-0,1,0,-0.236781880259514,0.966452360153198,-0.0995208248496056,0,0.997704029083252,-0.0677256807684898,-0.20475073158741,0.977241158485413,0.0554696470499039,-0.221464022994041,0.974918246269226,-0.0220951903611422,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0.204750746488571,0.977241158485413,-0.0554696545004845,0,0.997703969478607,0.0677258297801018,0.23678195476532,0.966452240943909,0.0995210781693459,0.221464082598686,0.974918246269226,0.0220953319221735,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0,0.236782073974609,0.966452240943909,-0.0995211005210876,0,0.997703969478607,-0.0677258521318436,0.204750806093216,0.977241098880768,0.0554696656763554,0.221464142203331,0.974918186664581,-0.0220953188836575,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1, +0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1, +-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0 + } + BinormalsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *2304 { + a: 0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0.26148721575737,-0,0.965207040309906, +0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.97571212053299,0.00952975451946259,0.218849271535873,0.997704029083252,-0.0677256807684898,0,0.972207129001617,-0.145124465227127,0.183717742562294,0.977037787437439,-0.0680116266012192,0.201919630169868,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,0.218849420547485,-0.0095297135412693,0.997703969478607,0,0.0677258297801018,0.972207069396973,0.183717846870422,0.145124778151512,0.977037727832794,0.20191977918148,0.0680118054151535,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.975712060928345,-0.00952969118952751,-0.218849584460258,0.997703969478607,0.0677258297801018,0,0.972207009792328,0.145124763250351,-0.183717995882034,0.977037727832794,0.0680118054151535,-0.201919928193092,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0.97571212053299,-0.218849301338196,0.00952974148094654,0.997703969478607,0,-0.0677259787917137,0.972207069396973,-0.183717638254166,-0.145125105977058,0.977037727832794,-0.201919630169868,-0.068011961877346,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.218849286437035,0.00952974148094654,-0.97571212053299,0,-0.0677256807684898,-0.997704029083252,0.183717831969261,-0.145124509930611,-0.972207069396973,0.201919674873352,-0.0680116564035416,-0.977037787437439,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.218849420547485,0.0095297172665596,0.97571212053299,0,-0.0677257031202316,0.997704029083252,-0.183717906475067,-0.145124524831772,0.972207069396973,-0.201919823884964,-0.068011686205864,0.977037727832794,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.972207129001617,0.145124465227127,-0.183717742562294,0.997704029083252,0.0677256733179092,0,0.97571212053299,-0.00952975824475288,-0.218849256634712,0.977037787437439,0.0680116191506386,-0.201919630169868,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403, +1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,0.00952975172549486,-0.218849286437035,0.997703969478607,-0.0677258223295212,0,0.972207069396973,-0.14512474834919,-0.183717682957649,0.977037847042084,-0.0680117681622505,-0.20191964507103,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,0.972207069396973,0.14512474834919,0.183717668056488,0.997703969478607,0.0677258297801018,0,0.97571212053299,-0.00952975451946259,0.218849271535873,0.977037847042084,0.0680117756128311,0.201919630169868,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,1,-0,-0,1,-0,0,1,-0,0,1,-0,0,0.972207069396973,-0.183717831969261,-0.145124778151512,0.997703969478607,0,-0.0677258223295212,0.97571212053299,-0.218849405646324,0.00952972564846277,0.977037727832794,-0.20191977918148,-0.0680117979645729,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,-0.218849420547485,-0.0095297247171402,0.997703969478607,0,0.0677259713411331,0.972207009792328,-0.183717757463455,0.145125061273575,0.977037727832794,-0.201919749379158,0.0680119395256042,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,0.972207009792328,0.183717772364616,-0.145125061273575,0.997703969478607,0,-0.0677259787917137,0.97571212053299,0.218849420547485,0.00952971447259188,0.977037727832794,0.20191977918148,-0.0680119544267654,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,-0,0.965206980705261,0.261487156152725,0,1,-0,0,1,0,0,1,0,0,1,0,0,0.972207009792328,-0.14512474834919,0.183718010783195,0.997703969478607,-0.0677258223295212,0,0.975712060928345,0.00952969118952751,0.218849584460258,0.977037727832794,-0.0680117979645729,0.201919928193092,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403, +1,-0,0,1,-0,0,1,-0,0,1,-0,0,0.975712060928345,-0.00952969398349524,0.218849569559097,0.997704029083252,0.0677256733179092,0,0.972207069396973,0.145124465227127,0.18371807038784,0.977037727832794,0.0680116564035416,0.201919972896576,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0.972207069396973,-0.145124480128288,-0.183718055486679,0.997704029083252,-0.0677256807684898,0,0.975712060928345,0.00952969398349524,-0.218849569559097,0.977037727832794,-0.0680116638541222,-0.201919972896576,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,1,0,0,1,0,0,1,0,0,1,0,0,0.972207069396973,0.183717623353004,0.145125105977058,0.997703969478607,0,0.0677259713411331,0.97571212053299,0.218849316239357,-0.00952974893152714,0.977037847042084,0.201919630169868,0.0680119544267654,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.97571212053299,0.218849271535873,0.00952975638210773,0.997703969478607,0,-0.0677258223295212,0.972207069396973,0.183717668056488,-0.145124807953835,0.977037847042084,0.201919630169868,-0.0680118054151535,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.972207069396973,-0.18371769785881,0.145124822854996,0.997703969478607,0,0.0677258297801018,0.97571212053299,-0.218849286437035,-0.00952974613755941,0.977037847042084,-0.201919630169868,0.0680118054151535,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,-0.183717846870422,0.145124554634094,-0.972207069396973,0,0.0677257031202316,-0.997704029083252,-0.218849360942841,-0.0095297284424305,-0.97571212053299,-0.20191977918148,0.068011686205864,-0.977037727832794,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906, +0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.218849450349808,0.00952971167862415,-0.97571212053299,0,-0.0677258521318436,-0.997703969478607,-0.1837178170681,-0.145124852657318,-0.972207069396973,-0.201919764280319,-0.0680118426680565,-0.977037727832794,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,0,-1,0,0,-1,0.183717772364616,0.145124807953835,-0.972207069396973,0,0.0677258297801018,-0.997703969478607,0.218849375844002,-0.00952972657978535,-0.97571212053299,0.201919689774513,0.0680118054151535,-0.977037727832794,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0.183717876672745,0.145124495029449,0.972207069396973,0,0.0677256807684898,0.997704029083252,0.218849375844002,-0.00952972192317247,0.97571212053299,0.20191977918148,0.0680116564035416,0.977037727832794,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.218849420547485,0.0095297135412693,0.97571212053299,0,-0.0677258297801018,0.997703969478607,0.183717846870422,-0.145124778151512,0.972207069396973,0.20191977918148,-0.0680118054151535,0.977037727832794,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,-0.183717921376228,0.145124837756157,0.972207009792328,0,0.0677258521318436,0.997703969478607,-0.21884948015213,-0.00952970236539841,0.97571212053299,-0.201919838786125,0.0680118277668953,0.977037727832794,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0, +1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1, +0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1 + } + TangentsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *542 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25,0.5,0.125,0.5,0,0.5,1,0.625,0.125,0.5,0.25,0.375,0.125,0.5,0.375,0.625,0.375,0.75,0.25,0.5,0.5,0.375,0.375,0.25,0.25,0.5,0.625,0.625,0.625,0.875,0.125,0.5,0.75,0.375,0.625,0.125,0.125,0.5,0.875,0.625,0.875,0.75,0,0.5,1,0.375,0.875,0.25,0,0.75,0.125,0.75,0,0.875,0.125,0.75,0.25,0.25,0.125,0.25,0,0.25,0.25,0.125,0.125,0.4375,0.0625,0.375,0.0625,0.4375,0,0.4375,1,0.5,0.0625,0.4375,0.125,0.4375,0.3125,0.375,0.3125,0.3125,0.25,0.4375,0.25,0.5,0.3125,0.4375,0.375,0.4375,0.5625,0.375,0.5625,0.125,0.1875,0.4375,0.5,0.5,0.5625,0.4375,0.625,0.4375,0.8125,0.375,0.8125,0.1875,0,0.4375,0.75,0.5,0.8125,0.4375,0.875,0.6875,0.0625,0.625,0.0625,0.625,0.9375,0.6875,0,0.75,0.0625,0.6875,0.125,0.1875,0.0625,0.375,0.6875,0.125,0.0625,0.1875,0,0.25,0.0625,0.1875,0.125,0.5625,0.0625,0.5625,0,0.5625,1,0.5625,0.125,0.5625,0.1875,0.625,0.1875,0.5625,0.25,0.5,0.1875,0.4375,0.1875,0.375,0.1875,0.5625,0.3125,0.625,0.3125,0.6875,0.25,0.5625,0.375,0.5625,0.4375,0.625,0.4375,0.8125,0.25,0.5625,0.5,0.5,0.4375,0.4375,0.4375,0.375,0.4375,0.1875,0.25,0.5625,0.5625,0.625,0.5625,0.875,0.1875,0.5625,0.625,0.5625,0.6875,0.625,0.6875,0.875,0.0625,0.5625,0.75,0.5,0.6875,0.4375,0.6875,0.375,0.6875,0.5625,0.8125,0.625,0.8125,0.8125,0,0.5625,0.875,0.5625,0.9375,0.625,0.9375,0.5625,1,0.5,0.9375,0.4375,0.9375,0.4375,1,0.375,0.9375,0.3125,0,0.8125,0.0625,0.8125,0,0.875,0.0625,0.8125,0.125,0.8125,0.1875,0.875,0.1875,0.8125,0.25,0.75,0.1875,0.6875,0.1875,0.6875,0.25,0.3125,0.0625,0.3125,0,0.3125,0.125,0.3125,0.1875,0.3125,0.25,0.25,0.1875,0.1875,0.1875,0.1875,0.25,0.125,0.1875,0.4375,0.125,0.375,0.125,0.375,0.0625,0.4375,0.0625,0.4375,0.375,0.375,0.375,0.375,0.3125,0.4375,0.3125,0.4375,0.625,0.375,0.625,0.375,0.5625,0.4375,0.5625,0.4375,0.875,0.375,0.875,0.375,0.8125,0.4375,0.8125,0.6875,0.125,0.625,0.125,0.625,0.0625,0.6875,0.0625,0.1875,0.125,0.125,0.125,0.125,0.0625,0.1875,0.0625,0.5,0.0625,0.5,0,0.5625,0, +0.5625,0.0625,0.5625,0.125,0.625,0.1875,0.5625,0.1875,0.5,0.1875,0.5,0.25,0.4375,0.25,0.4375,0.1875,0.5,0.3125,0.5625,0.25,0.5625,0.3125,0.5625,0.375,0.625,0.375,0.625,0.4375,0.5625,0.4375,0.5,0.4375,0.5,0.5,0.4375,0.5,0.4375,0.4375,0.5,0.5625,0.5625,0.5,0.5625,0.5625,0.5625,0.625,0.625,0.625,0.625,0.6875,0.5625,0.6875,0.5,0.6875,0.5,0.75,0.4375,0.75,0.4375,0.6875,0.5,0.8125,0.5625,0.75,0.5625,0.8125,0.5625,0.875,0.625,0.875,0.625,0.9375,0.5625,0.9375,0.5,0.9375,0.5,1,0.4375,1,0.4375,0.9375,0.75,0.0625,0.75,0,0.8125,0,0.8125,0.0625,0.8125,0.125,0.875,0.125,0.875,0.1875,0.8125,0.1875,0.75,0.1875,0.75,0.25,0.6875,0.25,0.6875,0.1875,0.25,0.0625,0.25,0,0.3125,0,0.3125,0.0625,0.3125,0.125,0.375,0.1875,0.3125,0.1875,0.25,0.1875,0.25,0.25,0.1875,0.25,0.1875,0.1875,0.375,0,0.4375,0,0.5,0.125,0.375,0.25,0.5,0.375,0.375,0.5,0.5,0.625,0.375,0.75,0.5,0.875,0.625,0,0.6875,0,0.75,0.125,0.125,0,0.1875,0,0.25,0.125,0.625,0.25,0.625,0.3125,0.625,0.5,0.375,0.4375,0.625,0.5625,0.625,0.75,0.375,0.6875,0.625,0.8125,0.625,1,0.5625,1,0.375,1,0.375,0.9375,0.875,0,0.875,0.0625,0.875,0.25,0.8125,0.25,0.3125,0.25,0.125,0.25,0.125,0.1875 + } + UVIndex: *768 { + a: 51,19,47,46,57,24,53,52,63,30,59,58,69,36,65,64,75,17,71,70,81,45,78,76,50,15,83,82,85,17,87,86,89,18,55,90,56,18,88,92,95,21,97,96,100,23,61,101,62,23,99,104,107,27,109,108,112,29,67,113,68,29,111,115,118,33,120,119,122,35,124,123,74,39,128,127,130,40,132,131,134,41,136,135,80,43,138,137,139,19,91,140,142,44,144,143,47,0,48,46,48,15,50,46,50,14,51,46,53,2,55,52,55,18,56,52,56,20,57,52,59,4,61,58,61,23,62,58,62,26,63,58,65,6,67,64,67,29,68,64,68,32,69,64,71,1,73,70,73,39,74,70,74,38,75,70,78,12,79,76,79,43,80,76,80,42,81,76,83,1,71,82,71,17,85,82,85,14,50,82,87,3,88,86,88,18,89,86,89,14,85,86,55,2,91,90,91,19,51,90,51,14,89,90,88,3,93,92,93,21,95,92,95,20,56,92,97,5,99,96,99,23,100,96,100,20,95,96,61,4,102,101,102,24,57,101,57,20,100,101,99,5,105,104,105,27,107,104,107,26,62,104,109,7,111,108,111,29,112,108,112,26,107,108,67,6,114,113,114,30,63,113,63,26,112,113,111,7,116,115,116,33,118,115,118,32,68,115,120,9,121,119,121,35,122,119,122,32,118,119,124,8,125,123,125,36,69,123,69,32,122,123,128,10,129,127,129,40,130,127,130,38,74,127,132,11,133,131,133,41,134,131,134,38,130,131,136,3,87,135,87,17,75,135,75,38,134,135,138,0,47,137,47,19,139,137,139,42,80,137,91,2,141,140,141,44,142,140,142,42,139,140,144,13,145,143,145,45,81,143,81,42,142,143,146,149,148,147,150,153,152,151,154,157,156,155,158,161,160,159,162,165,164,163,166,169,168,167,170,173,172,171,174,176,175,163,177,180,179,178,181,183,182,178,184,187,186,185,188,191,190,189,192,194,193,189,195,198,197,196,199,202,201,200,203,205,204,200,206,209,208,207,210,213,212,211,214,217,216,215,218,221,220,219,222,225,224,223,226,229,228,227,230,232,231,147,233,236,235,234,148,149,238,237,238,149,170,171,170,149,146,239,152,153,179,240,179,153,181,178,181,153,150,241,156,157,190,242,190,157,192,189,192,157,154,243,160,161,201,244,201,161,203,200,203,161,158,245,164,165,247,246,247,165,214,215,214,165,162,248,168,169,250,249,250,169,226,227,226,169,166,251,172,173,164,246,164,173,174,163,174,173,170,239,175,176,182,252,182,176,177,178,177,176,174,239, +179,180,231,240,231,180,146,147,146,180,177,239,182,183,253,252,253,183,184,185,184,183,181,241,186,187,193,254,193,187,188,189,188,187,184,241,190,191,255,242,255,191,150,151,150,191,188,241,193,194,256,254,256,194,195,196,195,194,192,243,197,198,204,257,204,198,199,200,199,198,195,243,201,202,258,244,258,202,154,155,154,202,199,243,204,205,259,257,259,205,206,207,206,205,203,245,208,209,261,260,261,209,210,211,210,209,206,245,212,213,263,262,263,213,158,159,158,213,210,245,216,217,265,264,265,217,218,219,218,217,214,248,220,221,267,266,267,221,222,223,222,221,218,248,224,225,175,252,175,225,162,163,162,225,222,248,228,229,148,237,148,229,230,147,230,229,226,251,231,232,268,240,268,232,233,234,233,232,230,251,235,236,270,269,270,236,166,167,166,236,233,251 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *384 { + a: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Model: 2359439406816, "Model::", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",-1.04023893373156,0.998288783259251,-1.04375962988677 + P: "Lcl Scaling", "Lcl Scaling", "", "A",10,10,10 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 2359439411456, "Model::", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",1.04023893373156,-0.998288783259251,1.04375962988677 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 2359439409136, "Model::", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",-1.0671176743957,0.998288783259251,9.39023469168045 + P: "Lcl Scaling", "Lcl Scaling", "", "A",10,10,10 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 2359439416096, "Model::", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",1.04023893373156,-0.998288783259251,1.1806740271636 + P: "Lcl Scaling", "Lcl Scaling", "", "A",0.77384837213491,0.77384837213491,0.77384837213491 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Material: 2359823919504, "Material::Mat_Green", "" { + Version: 102 + ShadingModel: "lambert" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",0,1,0 + P: "DiffuseFactor", "Number", "", "A",0.800000011920929 + P: "TransparencyFactor", "Number", "", "A",1 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",0,0.800000011920929,0 + P: "Opacity", "double", "Number", "",1 + } + } + Material: 2359823921584, "Material::Mat_Red", "" { + Version: 102 + ShadingModel: "lambert" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",1,0,0 + P: "DiffuseFactor", "Number", "", "A",0.800000011920929 + P: "TransparencyFactor", "Number", "", "A",1 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",0.800000011920929,0,0 + P: "Opacity", "double", "Number", "",1 + } + } + AnimationStack: 2359349464816, "AnimStack::Take 001", "" { + Properties70: { + P: "LocalStart", "KTime", "Time", "",1924423250 + P: "LocalStop", "KTime", "Time", "",230930790000 + P: "ReferenceStart", "KTime", "Time", "",1924423250 + P: "ReferenceStop", "KTime", "Time", "",230930790000 + } + } + AnimationLayer: 2359327403664, "AnimLayer::BaseLayer", "" { + } +} + +; Object connections +;------------------------------------------------------------------ + +Connections: { + + ;Model::, Model::RootNode + C: "OO",2359439406816,0 + + ;Model::, Model::RootNode + C: "OO",2359439409136,0 + + ;AnimLayer::BaseLayer, AnimStack::Take 001 + C: "OO",2359327403664,2359349464816 + + ;Geometry::, Model:: + C: "OO",2358377979296,2359439406816 + + ;Material::Mat_Green, Model:: + C: "OO",2359823919504,2359439406816 + + ;Model::, Model:: + C: "OO",2359439411456,2359439406816 + + ;Geometry::, Model:: + C: "OO",2358377961872,2359439411456 + + ;Material::Mat_Green, Model:: + C: "OO",2359823919504,2359439411456 + + ;Geometry::, Model:: + C: "OO",2358377982464,2359439409136 + + ;Material::Mat_Red, Model:: + C: "OO",2359823921584,2359439409136 + + ;Model::, Model:: + C: "OO",2359439416096,2359439409136 + + ;Geometry::, Model:: + C: "OO",2358377979824,2359439416096 + + ;Material::Mat_Red, Model:: + C: "OO",2359823921584,2359439416096 +} +;Takes section +;---------------------------------------------------- + +Takes: { + Current: "Take 001" + Take: "Take 001" { + FileName: "Take_001.tak" + LocalTime: 1924423250,230930790000 + ReferenceTime: 1924423250,230930790000 + } +} diff --git a/test/models/FBX/cubes_with_mirroring_and_pivot.fbx b/test/models/FBX/cubes_with_mirroring_and_pivot.fbx new file mode 100644 index 000000000..172bf2cb5 --- /dev/null +++ b/test/models/FBX/cubes_with_mirroring_and_pivot.fbx @@ -0,0 +1,855 @@ +; FBX 7.5.0 project file +; ---------------------------------------------------- + +FBXHeaderExtension: { + FBXHeaderVersion: 1003 + FBXVersion: 7500 + CreationTimeStamp: { + Version: 1000 + Year: 2019 + Month: 5 + Day: 14 + Hour: 17 + Minute: 27 + Second: 42 + Millisecond: 70 + } + Creator: "FBX SDK/FBX Plugins version 2018.1.1" + SceneInfo: "SceneInfo::GlobalInfo", "UserData" { + Type: "UserData" + Version: 100 + MetaData: { + Version: 100 + Title: "" + Subject: "" + Author: "" + Keywords: "" + Revision: "" + Comment: "" + } + Properties70: { + P: "DocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\cubes_with_mirroring_and_pivot.fbx" + P: "SrcDocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\cubes_with_mirroring_and_pivot.fbx" + P: "Original", "Compound", "", "" + P: "Original|ApplicationVendor", "KString", "", "", "Autodesk" + P: "Original|ApplicationName", "KString", "", "", "Maya" + P: "Original|ApplicationVersion", "KString", "", "", "201800" + P: "Original|DateTime_GMT", "DateTime", "", "", "14/05/2019 16:27:42.070" + P: "Original|FileName", "KString", "", "", "U:\Some\Absolute\Path\cubes_with_mirroring_and_pivot.fbx" + P: "LastSaved", "Compound", "", "" + P: "LastSaved|ApplicationVendor", "KString", "", "", "Autodesk" + P: "LastSaved|ApplicationName", "KString", "", "", "Maya" + P: "LastSaved|ApplicationVersion", "KString", "", "", "201800" + P: "LastSaved|DateTime_GMT", "DateTime", "", "", "14/05/2019 16:27:42.070" + P: "Original|ApplicationActiveProject", "KString", "", "", "U:\Some\Absolute\Path" + } + } +} +GlobalSettings: { + Version: 1000 + Properties70: { + P: "UpAxis", "int", "Integer", "",1 + P: "UpAxisSign", "int", "Integer", "",1 + P: "FrontAxis", "int", "Integer", "",2 + P: "FrontAxisSign", "int", "Integer", "",1 + P: "CoordAxis", "int", "Integer", "",0 + P: "CoordAxisSign", "int", "Integer", "",1 + P: "OriginalUpAxis", "int", "Integer", "",1 + P: "OriginalUpAxisSign", "int", "Integer", "",1 + P: "UnitScaleFactor", "double", "Number", "",100 + P: "OriginalUnitScaleFactor", "double", "Number", "",1 + P: "AmbientColor", "ColorRGB", "Color", "",0,0,0 + P: "DefaultCamera", "KString", "", "", "Producer Perspective" + P: "TimeMode", "enum", "", "",11 + P: "TimeProtocol", "enum", "", "",2 + P: "SnapOnFrameMode", "enum", "", "",0 + P: "TimeSpanStart", "KTime", "Time", "",1924423250 + P: "TimeSpanStop", "KTime", "Time", "",384884650000 + P: "CustomFrameRate", "double", "Number", "",-1 + P: "TimeMarker", "Compound", "", "" + P: "CurrentTimeMarker", "int", "Integer", "",-1 + } +} + +; Documents Description +;------------------------------------------------------------------ + +Documents: { + Count: 1 + Document: 1827132552544, "", "Scene" { + Properties70: { + P: "SourceObject", "object", "", "" + P: "ActiveAnimStackName", "KString", "", "", "Take 001" + } + RootNode: 0 + } +} + +; Document References +;------------------------------------------------------------------ + +References: { +} + +; Object definitions +;------------------------------------------------------------------ + +Definitions: { + Version: 100 + Count: 13 + ObjectType: "GlobalSettings" { + Count: 1 + } + ObjectType: "AnimationStack" { + Count: 1 + PropertyTemplate: "FbxAnimStack" { + Properties70: { + P: "Description", "KString", "", "", "" + P: "LocalStart", "KTime", "Time", "",0 + P: "LocalStop", "KTime", "Time", "",0 + P: "ReferenceStart", "KTime", "Time", "",0 + P: "ReferenceStop", "KTime", "Time", "",0 + } + } + } + ObjectType: "AnimationLayer" { + Count: 1 + PropertyTemplate: "FbxAnimLayer" { + Properties70: { + P: "Weight", "Number", "", "A",100 + P: "Mute", "bool", "", "",0 + P: "Solo", "bool", "", "",0 + P: "Lock", "bool", "", "",0 + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BlendMode", "enum", "", "",0 + P: "RotationAccumulationMode", "enum", "", "",0 + P: "ScaleAccumulationMode", "enum", "", "",0 + P: "BlendModeBypass", "ULongLong", "", "",0 + } + } + } + ObjectType: "Geometry" { + Count: 4 + PropertyTemplate: "FbxMesh" { + Properties70: { + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BBoxMin", "Vector3D", "Vector", "",0,0,0 + P: "BBoxMax", "Vector3D", "Vector", "",0,0,0 + P: "Primary Visibility", "bool", "", "",1 + P: "Casts Shadows", "bool", "", "",1 + P: "Receive Shadows", "bool", "", "",1 + } + } + } + ObjectType: "Material" { + Count: 2 + PropertyTemplate: "FbxSurfaceLambert" { + Properties70: { + P: "ShadingModel", "KString", "", "", "Lambert" + P: "MultiLayer", "bool", "", "",0 + P: "EmissiveColor", "Color", "", "A",0,0,0 + P: "EmissiveFactor", "Number", "", "A",1 + P: "AmbientColor", "Color", "", "A",0.2,0.2,0.2 + P: "AmbientFactor", "Number", "", "A",1 + P: "DiffuseColor", "Color", "", "A",0.8,0.8,0.8 + P: "DiffuseFactor", "Number", "", "A",1 + P: "Bump", "Vector3D", "Vector", "",0,0,0 + P: "NormalMap", "Vector3D", "Vector", "",0,0,0 + P: "BumpFactor", "double", "Number", "",1 + P: "TransparentColor", "Color", "", "A",0,0,0 + P: "TransparencyFactor", "Number", "", "A",0 + P: "DisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "DisplacementFactor", "double", "Number", "",1 + P: "VectorDisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "VectorDisplacementFactor", "double", "Number", "",1 + } + } + } + ObjectType: "Model" { + Count: 4 + PropertyTemplate: "FbxNode" { + Properties70: { + P: "QuaternionInterpolate", "enum", "", "",0 + P: "RotationOffset", "Vector3D", "Vector", "",0,0,0 + P: "RotationPivot", "Vector3D", "Vector", "",0,0,0 + P: "ScalingOffset", "Vector3D", "Vector", "",0,0,0 + P: "ScalingPivot", "Vector3D", "Vector", "",0,0,0 + P: "TranslationActive", "bool", "", "",0 + P: "TranslationMin", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMax", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMinX", "bool", "", "",0 + P: "TranslationMinY", "bool", "", "",0 + P: "TranslationMinZ", "bool", "", "",0 + P: "TranslationMaxX", "bool", "", "",0 + P: "TranslationMaxY", "bool", "", "",0 + P: "TranslationMaxZ", "bool", "", "",0 + P: "RotationOrder", "enum", "", "",0 + P: "RotationSpaceForLimitOnly", "bool", "", "",0 + P: "RotationStiffnessX", "double", "Number", "",0 + P: "RotationStiffnessY", "double", "Number", "",0 + P: "RotationStiffnessZ", "double", "Number", "",0 + P: "AxisLen", "double", "Number", "",10 + P: "PreRotation", "Vector3D", "Vector", "",0,0,0 + P: "PostRotation", "Vector3D", "Vector", "",0,0,0 + P: "RotationActive", "bool", "", "",0 + P: "RotationMin", "Vector3D", "Vector", "",0,0,0 + P: "RotationMax", "Vector3D", "Vector", "",0,0,0 + P: "RotationMinX", "bool", "", "",0 + P: "RotationMinY", "bool", "", "",0 + P: "RotationMinZ", "bool", "", "",0 + P: "RotationMaxX", "bool", "", "",0 + P: "RotationMaxY", "bool", "", "",0 + P: "RotationMaxZ", "bool", "", "",0 + P: "InheritType", "enum", "", "",0 + P: "ScalingActive", "bool", "", "",0 + P: "ScalingMin", "Vector3D", "Vector", "",0,0,0 + P: "ScalingMax", "Vector3D", "Vector", "",1,1,1 + P: "ScalingMinX", "bool", "", "",0 + P: "ScalingMinY", "bool", "", "",0 + P: "ScalingMinZ", "bool", "", "",0 + P: "ScalingMaxX", "bool", "", "",0 + P: "ScalingMaxY", "bool", "", "",0 + P: "ScalingMaxZ", "bool", "", "",0 + P: "GeometricTranslation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricRotation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricScaling", "Vector3D", "Vector", "",1,1,1 + P: "MinDampRangeX", "double", "Number", "",0 + P: "MinDampRangeY", "double", "Number", "",0 + P: "MinDampRangeZ", "double", "Number", "",0 + P: "MaxDampRangeX", "double", "Number", "",0 + P: "MaxDampRangeY", "double", "Number", "",0 + P: "MaxDampRangeZ", "double", "Number", "",0 + P: "MinDampStrengthX", "double", "Number", "",0 + P: "MinDampStrengthY", "double", "Number", "",0 + P: "MinDampStrengthZ", "double", "Number", "",0 + P: "MaxDampStrengthX", "double", "Number", "",0 + P: "MaxDampStrengthY", "double", "Number", "",0 + P: "MaxDampStrengthZ", "double", "Number", "",0 + P: "PreferedAngleX", "double", "Number", "",0 + P: "PreferedAngleY", "double", "Number", "",0 + P: "PreferedAngleZ", "double", "Number", "",0 + P: "LookAtProperty", "object", "", "" + P: "UpVectorProperty", "object", "", "" + P: "Show", "bool", "", "",1 + P: "NegativePercentShapeSupport", "bool", "", "",1 + P: "DefaultAttributeIndex", "int", "Integer", "",-1 + P: "Freeze", "bool", "", "",0 + P: "LODBox", "bool", "", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",0,0,0 + P: "Lcl Rotation", "Lcl Rotation", "", "A",0,0,0 + P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1 + P: "Visibility", "Visibility", "", "A",1 + P: "Visibility Inheritance", "Visibility Inheritance", "", "",1 + } + } + } +} + +; Object properties +;------------------------------------------------------------------ + +Objects: { + Geometry: 1827080157856, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 1827080155296, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 1827080156320, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 1827080139424, "Geometry::", "Mesh" { + Vertices: *588 { + a: -0.499999970197678,-0.5,0.5,0.500000059604645,-0.5,0.5,-0.499999970197678,0.5,0.5,0.500000059604645,0.5,0.5,-0.499999970197678,0.5,-0.49999988079071,0.500000059604645,0.5,-0.49999988079071,-0.499999970197678,-0.5,-0.49999988079071,0.500000059604645,-0.5,-0.49999988079071,0,0,0.5,0,-0.5,0.5,0.500000059604645,0,0.5,0,0.5,0.5,-0.499999970197678,0,0.5,0,0.5,1.19209289550781e-07,0.500000059604645,0.5,1.19209289550781e-07,0,0.5,-0.49999988079071,-0.499999970197678,0.5,1.19209289550781e-07,0,0,-0.49999988079071,0.500000059604645,0,-0.49999988079071,0,-0.5,-0.49999988079071,-0.499999970197678,0,-0.49999988079071,0,-0.5,1.19209289550781e-07,0.500000059604645,-0.5,1.19209289550781e-07,-0.499999970197678,-0.5,1.19209289550781e-07,0.500000059604645,0,1.19209289550781e-07,-0.499999970197678,0,1.19209289550781e-07,-0.25,-0.25,0.5,-0.499999970197678,-0.25,0.5,-0.25,-0.5,0.5,0,-0.25,0.5,-0.25,0,0.5,-0.25,0.5,0.25,-0.499999970197678,0.5,0.25,-0.25,0.5,0.5,0,0.5,0.25,-0.25,0.5,1.19209289550781e-07,-0.25,0.25,-0.49999988079071,-0.499999970197678,0.25,-0.49999988079071,-0.25,0.5,-0.49999988079071,0,0.25,-0.49999988079071,-0.25,0,-0.49999988079071,-0.25,-0.5,-0.24999988079071,-0.499999970197678,-0.5,-0.24999988079071,-0.25,-0.5,-0.49999988079071,0,-0.5,-0.24999988079071,-0.25,-0.5,1.19209289550781e-07,0.500000059604645,-0.25,0.25,0.500000059604645,-0.25,0.5,0.500000059604645,-0.5,0.25,0.500000059604645,-0.25,1.19209289550781e-07,0.500000059604645,0,0.25,-0.499999970197678,-0.25,-0.24999988079071,-0.499999970197678,-0.25,-0.49999988079071,-0.499999970197678,-0.25,1.19209289550781e-07,-0.499999970197678,0,-0.24999988079071,0.250000059604645,-0.25,0.5,0.250000059604645,-0.5,0.5,0.250000059604645,0,0.5,0.250000059604645,0.25,0.5,0.500000059604645,0.25,0.5,0.250000059604645,0.5,0.5,0,0.25,0.5,-0.25,0.25,0.5,-0.499999970197678,0.25,0.5,0.250000059604645,0.5,0.25,0.500000059604645,0.5,0.25,0.250000059604645,0.5,1.19209289550781e-07,0.250000059604645,0.5,-0.24999988079071,0.500000059604645,0.5,-0.24999988079071,0.250000059604645,0.5,-0.49999988079071, +0,0.5,-0.24999988079071,-0.25,0.5,-0.24999988079071,-0.499999970197678,0.5,-0.24999988079071,0.250000059604645,0.25,-0.49999988079071,0.500000059604645,0.25,-0.49999988079071,0.250000059604645,0,-0.49999988079071,0.250000059604645,-0.25,-0.49999988079071,0.500000059604645,-0.25,-0.49999988079071,0.250000059604645,-0.5,-0.49999988079071,0,-0.25,-0.49999988079071,-0.25,-0.25,-0.49999988079071,0.250000059604645,-0.5,-0.24999988079071,0.500000059604645,-0.5,-0.24999988079071,0.250000059604645,-0.5,1.19209289550781e-07,0.250000059604645,-0.5,0.25,0,-0.5,0.25,-0.25,-0.5,0.25,-0.499999970197678,-0.5,0.25,0.500000059604645,-0.25,-0.24999988079071,0.500000059604645,0,-0.24999988079071,0.500000059604645,0.25,-0.24999988079071,0.500000059604645,0.25,1.19209289550781e-07,0.500000059604645,0.25,0.25,-0.499999970197678,-0.25,0.25,-0.499999970197678,0,0.25,-0.499999970197678,0.25,0.25,-0.499999970197678,0.25,1.19209289550781e-07,-0.499999970197678,0.25,-0.24999988079071,-0.594913899898529,0,0.594913899898529,-0.152911216020584,0,0.714658200740814,-0.594913899898529,-0.152911216020584,0.594913899898529,-0.152911216020584,-0.152911216020584,0.714658200740814,-0.594913899898529,0.594913899898529,7.29137497046395e-08,-0.152911216020584,0.714658200740814,7.29137497046395e-08,-0.594913899898529,0.594913899898529,0.152911216020584,-0.152911216020584,0.714658200740814,0.152911216020584,-0.594913899898529,0,-0.594913899898529,-0.152911216020584,0,-0.714658200740814,-0.594913899898529,0.152911216020584,-0.594913899898529,-0.152911216020584,0.152911216020584,-0.714658200740814,-0.594913899898529,-0.594913899898529,7.29137497046395e-08,-0.152911216020584,-0.714658200740814,7.29137497046395e-08,-0.594913899898529,-0.594913899898529,-0.152911216020584,-0.152911216020584,-0.714658200740814,-0.152911216020584,0.594913899898529,0,0.594913899898529,0.714658200740814,0,0.152911216020584,0.594913899898529,-0.152911216020584,0.594913899898529,0.714658200740814,-0.152911216020584,0.152911216020584,-0.714658200740814,0,-0.152911216020584,-0.594913899898529,-0.152911216020584,-0.594913899898529, +-0.714658200740814,-0.152911216020584,-0.152911216020584,8.62321627254444e-17,-0.594913899898529,0.594913899898529,8.62321627254444e-17,-0.152911216020584,0.714658200740814,0.152911230921745,-0.594913899898529,0.594913899898529,0.152911230921745,-0.152911216020584,0.714658200740814,0.152911230921745,0,0.714658200740814,0.594913899898529,0.152911216020584,0.594913899898529,0.152911230921745,0.152911216020584,0.714658200740814,8.62321627254444e-17,0.594913899898529,0.594913899898529,8.62321627254444e-17,0.152911216020584,0.714658200740814,-0.152911216020584,0.594913899898529,0.594913899898529,-0.152911216020584,0.152911216020584,0.714658200740814,8.62321627254444e-17,0.714658200740814,0.152911216020584,0.152911230921745,0.594913899898529,0.594913899898529,0.152911230921745,0.714658200740814,0.152911216020584,0.594913899898529,0.594913899898529,7.29137497046395e-08,0.152911230921745,0.714658200740814,7.29137497046395e-08,0.594913899898529,0.594913899898529,-0.152911216020584,0.152911230921745,0.714658200740814,-0.152911216020584,8.62321627254444e-17,0.594913899898529,-0.594913899898529,8.62321627254444e-17,0.714658200740814,-0.152911216020584,-0.152911216020584,0.594913899898529,-0.594913899898529,-0.152911216020584,0.714658200740814,-0.152911216020584,8.62321627254444e-17,0.152911216020584,-0.714658200740814,0.152911230921745,0.594913899898529,-0.594913899898529,0.152911230921745,0.152911216020584,-0.714658200740814,0.594913899898529,0,-0.594913899898529,0.152911230921745,0,-0.714658200740814,0.594913899898529,-0.152911216020584,-0.594913899898529,0.152911230921745,-0.152911216020584,-0.714658200740814,8.62321627254444e-17,-0.594913899898529,-0.594913899898529,8.62321627254444e-17,-0.152911216020584,-0.714658200740814,-0.152911216020584,-0.594913899898529,-0.594913899898529,-0.152911216020584,-0.152911216020584,-0.714658200740814,8.62321627254444e-17,-0.714658200740814,-0.152911216020584,0.152911230921745,-0.594913899898529,-0.594913899898529,0.152911230921745,-0.714658200740814,-0.152911216020584,0.594913899898529,-0.594913899898529,7.29137497046395e-08, +0.152911230921745,-0.714658200740814,7.29137497046395e-08,0.594913899898529,-0.594913899898529,0.152911216020584,0.152911230921745,-0.714658200740814,0.152911216020584,8.62321627254444e-17,-0.714658200740814,0.152911216020584,-0.152911216020584,-0.594913899898529,0.594913899898529,-0.152911216020584,-0.714658200740814,0.152911216020584,0.714658200740814,-0.152911216020584,7.29137497046395e-08,0.594913899898529,-0.594913899898529,-0.152911216020584,0.714658200740814,-0.152911216020584,-0.152911216020584,0.714658200740814,0,-0.152911216020584,0.594913899898529,0.152911216020584,-0.594913899898529,0.714658200740814,0.152911216020584,-0.152911216020584,0.714658200740814,0.152911216020584,7.29137497046395e-08,0.594913899898529,0.594913899898529,0.152911216020584,0.714658200740814,0.152911216020584,0.152911216020584,-0.714658200740814,-0.152911216020584,7.29137497046395e-08,-0.594913899898529,-0.594913899898529,0.152911216020584,-0.714658200740814,-0.152911216020584,0.152911216020584,-0.714658200740814,0,0.152911216020584,-0.594913899898529,0.152911216020584,0.594913899898529,-0.714658200740814,0.152911216020584,0.152911216020584,-0.714658200740814,0.152911216020584,7.29137497046395e-08,-0.594913899898529,0.594913899898529,-0.152911216020584,-0.714658200740814,0.152911216020584,-0.152911216020584,-0.541863918304443,-0.541864037513733,0.541863918304443,8.62321627254444e-17,0,0.714658200740814,-0.541863918304443,0.541863918304443,0.541863918304443,8.62321627254444e-17,0.714658200740814,7.29137497046395e-08,-0.541863918304443,0.541863918304443,-0.541863799095154,8.62321627254444e-17,0,-0.714658200740814,-0.541863918304443,-0.541864037513733,-0.541863799095154,8.62321627254444e-17,-0.714658200740814,7.29137497046395e-08,0.541863977909088,-0.541864037513733,0.541863918304443,0.714658200740814,0,7.29137497046395e-08,-0.714658200740814,0,7.29137497046395e-08,0.541863977909088,0.541863918304443,0.541863918304443,0.541863977909088,0.541863918304443,-0.541863799095154,0.541863977909088,-0.541864037513733,-0.541863799095154 + } + PolygonVertexIndex: *768 { + a: 99,98,100,-102,103,102,104,-106,107,106,108,-110,111,110,112,-114,115,114,116,-118,118,106,119,-121,122,121,123,-125,125,114,126,-128,129,128,130,-132,132,128,133,-135,136,135,137,-139,140,139,141,-143,143,139,144,-146,147,146,148,-150,151,150,152,-154,154,150,155,-157,158,157,159,-161,161,121,162,-164,164,157,165,-167,167,146,168,-170,170,135,171,-173,173,110,174,-176,176,98,177,-179,179,102,180,-182,100,182,162,-102,162,121,122,-102,122,183,99,-102,104,184,130,-106,130,128,132,-106,132,185,103,-106,108,186,141,-110,141,139,143,-110,143,187,107,-110,112,188,152,-114,152,150,154,-114,154,189,111,-114,116,190,159,-118,159,157,164,-118,164,191,115,-118,119,188,112,-121,112,110,173,-121,173,192,118,-121,123,190,116,-125,116,114,125,-125,125,183,122,-125,126,193,133,-128,133,128,129,-128,129,183,125,-128,130,184,177,-132,177,98,99,-132,99,183,129,-132,133,193,171,-135,171,135,136,-135,136,185,132,-135,137,194,144,-139,144,139,140,-139,140,185,136,-139,141,186,180,-143,180,102,103,-143,103,185,140,-143,144,194,168,-146,168,146,147,-146,147,187,143,-146,148,195,155,-150,155,150,151,-150,151,187,147,-150,152,188,119,-154,119,106,107,-154,107,187,151,-154,155,195,165,-157,165,157,158,-157,158,189,154,-157,159,190,123,-161,123,121,161,-161,161,189,158,-161,162,182,174,-164,174,110,111,-164,111,189,161,-164,165,195,148,-167,148,146,167,-167,167,191,164,-167,168,194,137,-170,137,135,170,-170,170,191,167,-170,171,193,126,-173,126,114,115,-173,115,191,170,-173,174,182,100,-176,100,98,176,-176,176,192,173,-176,177,184,104,-179,104,102,179,-179,179,192,176,-179,180,186,108,-182,108,106,118,-182,118,192,179,-182,30,26,27,-13,35,31,32,-17,40,36,37,-21,45,41,42,-24,50,46,47,-11,54,51,52,-21,29,55,56,-10,57,58,59,-11,61,62,33,-12,34,64,60,-12,66,67,68,-15,70,71,38,-16,39,73,69,-16,75,76,77,-19,79,80,43,-20,44,81,78,-20,83,84,48,-23,85,86,28,-10,49,88,82,-23,89,90,74,-19,91,92,65,-15,53,93,87,-24,94,95,63,-13,96,97,72,-17,27,26,28,-1,28,26,29,-10,29,26,30,-9,32,31,33,-3,33,31,34,-12,34,31,35,-14,37,36,38,-5,38,36,39, +-16,39,36,40,-18,42,41,43,-7,43,41,44,-20,44,41,45,-22,47,46,48,-2,48,46,49,-23,49,46,50,-25,52,51,42,-7,42,51,53,-24,53,51,54,-26,56,55,47,-2,47,55,57,-11,57,55,29,-9,59,58,60,-4,60,58,61,-12,61,58,57,-9,33,62,63,-3,63,62,30,-13,30,62,61,-9,60,64,65,-4,65,64,66,-15,66,64,34,-14,68,67,69,-6,69,67,70,-16,70,67,66,-14,38,71,72,-5,72,71,35,-17,35,71,70,-14,69,73,74,-6,74,73,75,-19,75,73,39,-18,77,76,78,-8,78,76,79,-20,79,76,75,-18,43,80,52,-7,52,80,40,-21,40,80,79,-18,78,81,82,-8,82,81,83,-23,83,81,44,-22,48,84,56,-2,56,84,85,-10,85,84,83,-22,28,86,87,-1,87,86,45,-24,45,86,85,-22,82,88,77,-8,77,88,89,-19,89,88,49,-25,74,90,68,-6,68,90,91,-15,91,90,89,-25,65,92,59,-4,59,92,50,-11,50,92,91,-25,87,93,27,-1,27,93,94,-13,94,93,53,-26,63,95,32,-3,32,95,96,-17,96,95,94,-26,72,97,37,-5,37,97,54,-21,54,97,96,-26 + } + Edges: *384 { + a: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,102,104,105,108,109,110,114,116,117,120,121,122,126,128,129,132,133,134,138,140,141,144,145,146,150,152,153,156,158,162,164,165,168,170,174,176,180,181,182,186,188,193,194,198,205,206,210,212,216,217,218,222,224,229,230,234,241,242,246,248,252,253,254,258,260,266,270,277,278,282,284,290,294,296,301,302,306,314,318,320,326,330,332,338,342,350,354,356,362,366,368,374,378,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,481,482,483,485,490,491,493,494,495,497,502,503,505,506,507,509,514,515,517,518,519,521,526,527,529,530,531,533,538,539,541,543,545,550,551,553,555,557,563,565,566,567,569,575,577,578,581,589,590,593,599,601,602,603,605,611,613,614,617,625,626,629,635,637,638,639,641,647,649,653,661,662,665,671,673,677,683,685,686,689,697,701,707,709,713,719,721,725,733,737,743,745,749,755,757,761 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *2304 { + a: -0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487185955048,0.965206921100616,0,-0.261487185955048,0.965206921100616,0,-0.261487185955048,0.965206921100616,0,-0.261487185955048,0.965206921100616,0,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0.261487126350403,0,-0.965206980705261, +0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0.261487185955048,-0.965206921100616,0,0.261487185955048,-0.965206921100616,0,0.261487185955048,-0.965206921100616,0,0.261487185955048,-0.965206921100616,0,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.211917281150818,-0.211917445063591,0.954034626483917,0,0,1,-0.211917281150818,-0.21191743016243,0.954034626483917,-0.211917266249657,-0.211917445063591,0.954034626483917,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,-0.211917445063591,0.954034626483917,0.211917281150818, +0,1,0,-0.211917445063591,0.954034626483917,0.211917281150818,-0.211917445063591,0.954034626483917,0.211917266249657,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,1,0,0,1,0,0,1,0,0,1,0,-0.211917594075203,0.211917579174042,-0.954034507274628,0,0,-1,-0.211917594075203,0.211917579174042,-0.954034507274628,-0.211917594075203,0.211917564272881,-0.954034507274628,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.211917325854301,-0.954034626483917,-0.211917325854301,0,-1,0,-0.211917325854301,-0.954034686088562,-0.211917325854301,-0.211917355656624,-0.954034686088562,-0.211917355656624,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.954034626483917,-0.211917251348495,0.21191731095314,1,0,0,0.954034626483917,-0.211917251348495,0.211917340755463,0.954034745693207,-0.211917266249657,0.211917325854301,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,1,0,0,1,0,0,1,0,0,1,0,0,-0.954034686088562,-0.211917355656624,-0.211917459964752,-1,0,0,-0.954034626483917,-0.211917325854301,-0.211917445063591,-0.954034686088562,-0.211917355656624,-0.211917474865913,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0.211917281150818,-0.211917400360107,0.954034626483917,0,0,1,0.211917266249657,-0.211917415261269,0.954034626483917,0.211917266249657,-0.211917415261269,0.954034626483917,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261, +0,0,1,0,0,1,0,0,1,0,0,1,0.211917296051979,0.211917415261269,0.954034626483917,0,0,1,0.211917296051979,0.211917415261269,0.954034626483917,0.211917281150818,0.211917415261269,0.954034626483917,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,-0.211917281150818,0.211917445063591,0.954034626483917,0,0,1,-0.211917281150818,0.211917445063591,0.954034626483917,-0.211917266249657,0.211917445063591,0.954034626483917,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0.211917445063591,0.954034626483917,0.211917445063591,0,1,0,0.211917415261269,0.954034566879272,0.211917415261269,0.211917445063591,0.954034626483917,0.211917445063591,0.261487185955048,0.965206921100616,0,0.261487185955048,0.965206921100616,0,0.261487185955048,0.965206921100616,0,0.261487185955048,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,0,0.211917445063591,0.954034626483917,-0.211917489767075,0,1,0,0.21191743016243,0.954034566879272,-0.211917489767075,0.211917445063591,0.954034566879272,-0.211917474865913,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,1,0,0,1,0,0,1,0,0,1,0,-0.211917459964752,0.954034686088562,-0.211917340755463,0,1,0,-0.211917445063591,0.954034626483917,-0.21191731095314,-0.211917489767075,0.954034686088562,-0.211917355656624,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,0,0.211917608976364,0.211917579174042,-0.954034507274628,0,0,-1,0.211917608976364,0.211917564272881,-0.954034566879272,0.211917594075203,0.211917579174042,-0.954034507274628,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261, +0.261487126350403,0,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0.211917579174042,-0.211917534470558,-0.954034507274628,0,0,-1,0.211917594075203,-0.211917549371719,-0.954034507274628,0.211917594075203,-0.211917519569397,-0.954034507274628,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.211917594075203,-0.211917549371719,-0.954034507274628,0,0,-1,-0.211917579174042,-0.211917534470558,-0.954034566879272,-0.211917594075203,-0.211917519569397,-0.954034507274628,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0.211917340755463,-0.954034686088562,-0.211917519569397,0,-1,0,0.211917325854301,-0.954034626483917,-0.211917489767075,0.211917325854301,-0.954034686088562,-0.211917489767075,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.211917281150818,-0.954034626483917,0.211917445063591,0,-1,0,0.211917296051979,-0.954034626483917,0.211917445063591,0.211917266249657,-0.954034626483917,0.211917445063591,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.211917296051979,-0.954034626483917,0.211917296051979,0,-1,0,-0.211917296051979,-0.954034626483917,0.211917296051979,-0.211917281150818,-0.954034686088562,0.211917281150818,-0.261487185955048,-0.965206921100616,0,-0.261487185955048,-0.965206921100616,0,-0.261487185955048,-0.965206921100616,0,-0.261487185955048,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.954034626483917,-0.211917325854301,-0.211917400360107,1,0,0,0.954034686088562,-0.211917340755463,-0.211917400360107,0.954034686088562,-0.211917355656624,-0.21191743016243,0.965206980705261,0,-0.261487185955048, +0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,1,0,0,1,0,0,1,0,0,1,0,0,0.954034686088562,0.211917370557785,-0.211917489767075,1,0,0,0.954034686088562,0.211917355656624,-0.211917445063591,0.954034626483917,0.211917355656624,-0.211917445063591,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,1,0,0,1,0,0,1,0,0,1,0,0,0.954034626483917,0.211917296051979,0.211917385458946,1,0,0,0.954034626483917,0.211917296051979,0.211917385458946,0.954034626483917,0.211917266249657,0.211917355656624,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,1,0,0,1,0,0,1,0,0,1,0,0,-0.954034626483917,-0.211917251348495,0.211917400360107,-1,0,0,-0.954034626483917,-0.211917266249657,0.211917400360107,-0.954034626483917,-0.211917251348495,0.211917400360107,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.954034626483917,0.211917281150818,0.211917445063591,-1,0,0,-0.954034626483917,0.211917281150818,0.211917445063591,-0.954034626483917,0.211917266249657,0.211917445063591,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.954034566879272,0.211917355656624,-0.211917519569397,-1,0,0,-0.954034686088562,0.211917370557785,-0.211917534470558,-0.954034626483917,0.211917355656624,-0.211917504668236,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0, +1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0, +-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0 + } + NormalsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *2304 { + a: 0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0, +0,1,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,-0.0554696954786777,0.977241098880768,0.204750895500183,0.0677256807684898,0.997704029083252,-0,0.0995207726955414,0.966452240943909,0.236782029271126,0.022095151245594,0.974918127059937,0.221464186906815,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0554696545004845,0.204750746488571,-0.977241158485413,0.0677258297801018,0,-0.997703969478607,0.0995210781693459,0.23678195476532,-0.966452240943909,0.0220953319221735,0.221464082598686,-0.974918246269226,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.055469736456871,-0.977241158485413,-0.204751059412956,0.0677258297801018,-0.997703969478607,0,0.0995209664106369,-0.966452121734619,-0.236782252788544,0.0220952294766903,-0.974918127059937,-0.221464350819588,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,-0.0554696694016457,-0.204750820994377,0.977241218090057,0.0677259787917137,0,0.997703969478607,0.0995214134454727,-0.236782014369965,0.966452121734619,0.0220954976975918,-0.221464157104492,0.974918186664581,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0.204750746488571,0.977241218090057,0.0554696507751942,0,0.997704029083252,-0.0677256807684898,0.236781880259514,0.966452300548553,-0.0995208472013474,0.221463993191719,0.974918186664581,-0.0220952127128839,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0, +-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.204750791192055,0.977241098880768,-0.0554696619510651,0,0.997704029083252,0.0677257031202316,-0.236781939864159,0.966452240943909,0.099520817399025,-0.221464112401009,0.974918246269226,0.022095188498497,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0,-0.099520780146122,0.966452240943909,0.236781999468803,-0.0677256733179092,0.997704029083252,0,0.0554696880280972,0.977241098880768,0.204750865697861,-0.022095151245594,0.974918127059937,0.221464157104492,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0554696880280972,0.977241098880768,-0.204750865697861,0.0677258223295212,0.997703969478607,-0,0.0995210558176041,0.966452181339264,-0.236782059073448,0.0220952890813351,0.974918246269226,-0.221464201807976,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0995210707187653,0.966452240943909,-0.236782118678093,-0.0677258297801018,0.997703969478607,0,0.0554696954786777,0.977241098880768,-0.204750895500183,-0.0220952928066254,0.974918186664581,-0.221464231610298,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0995210558176041,0.236782118678093,-0.966452240943909,-0.0677258223295212,0,-0.997703969478607,0.0554696917533875,0.204750880599022,-0.977241098880768,-0.0220952853560448,0.221464216709137,-0.974918127059937,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0554697066545486,-0.204750955104828,-0.977241158485413,0.0677259713411331,0,-0.997703969478607,0.0995213314890862,-0.236782237887383,-0.966452181339264,0.0220954213291407,-0.221464306116104,-0.974918186664581,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0995213687419891,-0.236782059073448,-0.966452181339264, +-0.0677259787917137,0,-0.997703969478607,0.0554696545004845,-0.204750776290894,-0.977241158485413,-0.0220954604446888,-0.221464172005653,-0.974918246269226,0,0,-1,0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0995209515094757,-0.966452121734619,-0.236782252788544,-0.0677258223295212,-0.997703969478607,-0,0.0554697290062904,-0.977241098880768,-0.204751014709473,-0.0220952183008194,-0.974918127059937,-0.221464365720749,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,-0.0554697290062904,-0.977241158485413,0.204751014709473,0.0677256733179092,-0.997704029083252,0,0.099520668387413,-0.966452181339264,0.236782178282738,0.022095087915659,-0.974918127059937,0.221464276313782,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-1,0,0,-1,0,0,-1,-0,0,-1,0,-0.0995206907391548,-0.966452181339264,0.236782178282738,-0.0677256807684898,-0.997704029083252,-0,0.0554697178304195,-0.977241098880768,0.20475098490715,-0.0220951028168201,-0.974918127059937,0.221464276313782,0,-1,-0,0,-1,-0,-0,-1,0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.0995213836431503,-0.23678220808506,0.966452121734619,-0.0677259713411331,0,0.997703969478607,0.0554697066545486,-0.204750940203667,0.977241098880768,-0.0220954623073339,-0.221464291214943,0.974918186664581,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0.0554696954786777,0.204750895500183,0.977241098880768,0.0677258223295212,0,0.997703969478607,0.0995211154222488,0.236782103776932,0.966452181339264,0.0220953226089478,0.221464246511459,0.974918186664581,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,-0.0995211601257324,0.23678195476532,0.966452181339264,-0.0677258297801018,0,0.997703969478607,0.0554696619510651,0.204750776290894,0.977241218090057,-0.022095363587141,0.221464082598686,0.974918246269226,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0.236781939864159,0.966452240943909,0.0995208621025085, +-0,0.997704029083252,0.0677257031202316,0.204750806093216,0.977241158485413,-0.0554696656763554,0.221464112401009,0.974918186664581,0.0220951996743679,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.204750806093216,0.977241098880768,0.0554696694016457,0,0.997703969478607,-0.0677258521318436,-0.236782044172287,0.966452240943909,-0.0995211452245712,-0.221464172005653,0.974918246269226,-0.0220953542739153,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,0,1,-0,-0,1,0,-0,1,0,-0,1,0,-0.236781984567642,0.966452300548553,0.09952113032341,-0,0.997703969478607,0.0677258297801018,-0.204750761389732,0.977241158485413,-0.0554696582257748,-0.221464067697525,0.974918246269226,0.022095350548625,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,-0,-0,1,0,-0.236781880259514,0.966452360153198,-0.0995208248496056,0,0.997704029083252,-0.0677256807684898,-0.20475073158741,0.977241158485413,0.0554696470499039,-0.221464022994041,0.974918246269226,-0.0220951903611422,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0.204750746488571,0.977241158485413,-0.0554696545004845,0,0.997703969478607,0.0677258297801018,0.23678195476532,0.966452240943909,0.0995210781693459,0.221464082598686,0.974918246269226,0.0220953319221735,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0,0.236782059073448,0.966452240943909,-0.0995211154222488,0,0.997703969478607,-0.0677258521318436,0.204750806093216,0.977241098880768,0.0554696656763554,0.221464142203331,0.974918186664581,-0.0220953188836575,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1, +0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1, +-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0 + } + BinormalsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *2304 { + a: 0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0.26148721575737,-0,0.965207040309906, +0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.97571212053299,0.00952975451946259,0.218849271535873,0.997704029083252,-0.0677256807684898,0,0.972207129001617,-0.145124465227127,0.183717742562294,0.977037787437439,-0.0680116266012192,0.201919630169868,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,0.218849420547485,-0.0095297135412693,0.997703969478607,0,0.0677258297801018,0.972207069396973,0.183717846870422,0.145124778151512,0.977037727832794,0.20191977918148,0.0680118054151535,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.975712060928345,-0.00952968932688236,-0.21884959936142,0.997703969478607,0.0677258297801018,0,0.972207009792328,0.145124763250351,-0.183717966079712,0.977037727832794,0.0680118054151535,-0.201919928193092,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0.97571212053299,-0.218849316239357,0.00952973961830139,0.997703969478607,0,-0.0677259787917137,0.972207069396973,-0.183717638254166,-0.145125105977058,0.977037727832794,-0.201919630169868,-0.068011961877346,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.218849301338196,0.00952973961830139,-0.97571212053299,0,-0.0677256807684898,-0.997704029083252,0.1837178170681,-0.145124509930611,-0.972207069396973,0.201919689774513,-0.0680116564035416,-0.977037787437439,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.218849420547485,0.0095297172665596,0.97571212053299,0,-0.0677257031202316,0.997704029083252,-0.183717906475067,-0.145124524831772,0.972207069396973,-0.201919823884964,-0.068011686205864,0.977037727832794,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.972207129001617,0.145124465227127,-0.183717742562294,0.997704029083252,0.0677256733179092,0,0.97571212053299,-0.00952975824475288,-0.218849256634712,0.977037787437439,0.0680116191506386,-0.201919630169868,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403, +1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,0.00952975172549486,-0.218849286437035,0.997703969478607,-0.0677258223295212,0,0.972207069396973,-0.14512474834919,-0.183717682957649,0.977037847042084,-0.0680117681622505,-0.20191964507103,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,0.972207069396973,0.14512474834919,0.183717668056488,0.997703969478607,0.0677258297801018,0,0.97571212053299,-0.00952975451946259,0.218849271535873,0.977037847042084,0.0680117756128311,0.201919630169868,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,1,-0,-0,1,-0,0,1,-0,0,1,-0,0,0.972207069396973,-0.183717831969261,-0.145124778151512,0.997703969478607,0,-0.0677258223295212,0.97571212053299,-0.218849420547485,0.00952972378581762,0.977037727832794,-0.20191977918148,-0.0680117979645729,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,-0.218849420547485,-0.0095297247171402,0.997703969478607,0,0.0677259713411331,0.972207009792328,-0.183717742562294,0.145125061273575,0.977037727832794,-0.201919749379158,0.0680119395256042,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,0.972207009792328,0.183717772364616,-0.145125061273575,0.997703969478607,0,-0.0677259787917137,0.97571212053299,0.218849420547485,0.00952971447259188,0.977037727832794,0.20191977918148,-0.0680119544267654,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,-0,0.965206980705261,0.261487156152725,0,1,-0,0,1,0,0,1,0,0,1,0,0,0.972207009792328,-0.14512474834919,0.183717995882034,0.997703969478607,-0.0677258223295212,0,0.975712060928345,0.00952969118952751,0.218849584460258,0.977037727832794,-0.0680117979645729,0.201919928193092,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403, +1,-0,0,1,-0,0,1,-0,0,1,-0,0,0.975712060928345,-0.00952969212085009,0.218849584460258,0.997704029083252,0.0677256733179092,0,0.972207069396973,0.145124465227127,0.183718055486679,0.977037727832794,0.0680116564035416,0.201919972896576,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0.972207069396973,-0.145124480128288,-0.183718040585518,0.997704029083252,-0.0677256807684898,0,0.975712060928345,0.00952969398349524,-0.218849569559097,0.977037727832794,-0.0680116713047028,-0.201919972896576,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,1,0,0,1,0,0,1,0,0,1,0,0,0.972207069396973,0.183717623353004,0.145125105977058,0.997703969478607,0,0.0677259713411331,0.97571212053299,0.218849316239357,-0.00952974893152714,0.977037847042084,0.201919630169868,0.0680119544267654,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.97571212053299,0.218849271535873,0.00952975638210773,0.997703969478607,0,-0.0677258223295212,0.972207069396973,0.183717668056488,-0.145124807953835,0.977037847042084,0.201919630169868,-0.0680118054151535,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.972207069396973,-0.183717682957649,0.145124822854996,0.997703969478607,0,0.0677258297801018,0.97571212053299,-0.218849286437035,-0.00952974427491426,0.977037847042084,-0.201919630169868,0.0680118054151535,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,-0.183717846870422,0.145124554634094,-0.972207069396973,0,0.0677257031202316,-0.997704029083252,-0.218849360942841,-0.0095297284424305,-0.97571212053299,-0.20191977918148,0.068011686205864,-0.977037727832794,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906, +0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.218849450349808,0.00952971167862415,-0.97571212053299,0,-0.0677258521318436,-0.997703969478607,-0.1837178170681,-0.145124852657318,-0.972207069396973,-0.201919764280319,-0.0680118426680565,-0.977037727832794,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,0,-1,0,0,-1,0.183717772364616,0.145124807953835,-0.972207069396973,0,0.0677258297801018,-0.997703969478607,0.218849375844002,-0.00952972657978535,-0.97571212053299,0.201919689774513,0.0680118054151535,-0.977037727832794,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0.183717876672745,0.145124495029449,0.972207069396973,0,0.0677256807684898,0.997704029083252,0.218849375844002,-0.00952972192317247,0.97571212053299,0.20191977918148,0.0680116564035416,0.977037727832794,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.218849420547485,0.0095297135412693,0.97571212053299,0,-0.0677258297801018,0.997703969478607,0.183717846870422,-0.145124778151512,0.972207069396973,0.20191977918148,-0.0680118054151535,0.977037727832794,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,-0.183717906475067,0.145124837756157,0.972207009792328,0,0.0677258521318436,0.997703969478607,-0.21884948015213,-0.00952970236539841,0.97571212053299,-0.201919838786125,0.0680118277668953,0.977037727832794,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0, +1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1, +0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1 + } + TangentsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *542 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25,0.5,0.125,0.5,0,0.5,1,0.625,0.125,0.5,0.25,0.375,0.125,0.5,0.375,0.625,0.375,0.75,0.25,0.5,0.5,0.375,0.375,0.25,0.25,0.5,0.625,0.625,0.625,0.875,0.125,0.5,0.75,0.375,0.625,0.125,0.125,0.5,0.875,0.625,0.875,0.75,0,0.5,1,0.375,0.875,0.25,0,0.75,0.125,0.75,0,0.875,0.125,0.75,0.25,0.25,0.125,0.25,0,0.25,0.25,0.125,0.125,0.4375,0.0625,0.375,0.0625,0.4375,0,0.4375,1,0.5,0.0625,0.4375,0.125,0.4375,0.3125,0.375,0.3125,0.3125,0.25,0.4375,0.25,0.5,0.3125,0.4375,0.375,0.4375,0.5625,0.375,0.5625,0.125,0.1875,0.4375,0.5,0.5,0.5625,0.4375,0.625,0.4375,0.8125,0.375,0.8125,0.1875,0,0.4375,0.75,0.5,0.8125,0.4375,0.875,0.6875,0.0625,0.625,0.0625,0.625,0.9375,0.6875,0,0.75,0.0625,0.6875,0.125,0.1875,0.0625,0.375,0.6875,0.125,0.0625,0.1875,0,0.25,0.0625,0.1875,0.125,0.5625,0.0625,0.5625,0,0.5625,1,0.5625,0.125,0.5625,0.1875,0.625,0.1875,0.5625,0.25,0.5,0.1875,0.4375,0.1875,0.375,0.1875,0.5625,0.3125,0.625,0.3125,0.6875,0.25,0.5625,0.375,0.5625,0.4375,0.625,0.4375,0.8125,0.25,0.5625,0.5,0.5,0.4375,0.4375,0.4375,0.375,0.4375,0.1875,0.25,0.5625,0.5625,0.625,0.5625,0.875,0.1875,0.5625,0.625,0.5625,0.6875,0.625,0.6875,0.875,0.0625,0.5625,0.75,0.5,0.6875,0.4375,0.6875,0.375,0.6875,0.5625,0.8125,0.625,0.8125,0.8125,0,0.5625,0.875,0.5625,0.9375,0.625,0.9375,0.5625,1,0.5,0.9375,0.4375,0.9375,0.4375,1,0.375,0.9375,0.3125,0,0.8125,0.0625,0.8125,0,0.875,0.0625,0.8125,0.125,0.8125,0.1875,0.875,0.1875,0.8125,0.25,0.75,0.1875,0.6875,0.1875,0.6875,0.25,0.3125,0.0625,0.3125,0,0.3125,0.125,0.3125,0.1875,0.3125,0.25,0.25,0.1875,0.1875,0.1875,0.1875,0.25,0.125,0.1875,0.4375,0.125,0.375,0.125,0.375,0.0625,0.4375,0.0625,0.4375,0.375,0.375,0.375,0.375,0.3125,0.4375,0.3125,0.4375,0.625,0.375,0.625,0.375,0.5625,0.4375,0.5625,0.4375,0.875,0.375,0.875,0.375,0.8125,0.4375,0.8125,0.6875,0.125,0.625,0.125,0.625,0.0625,0.6875,0.0625,0.1875,0.125,0.125,0.125,0.125,0.0625,0.1875,0.0625,0.5,0.0625,0.5,0,0.5625,0, +0.5625,0.0625,0.5625,0.125,0.625,0.1875,0.5625,0.1875,0.5,0.1875,0.5,0.25,0.4375,0.25,0.4375,0.1875,0.5,0.3125,0.5625,0.25,0.5625,0.3125,0.5625,0.375,0.625,0.375,0.625,0.4375,0.5625,0.4375,0.5,0.4375,0.5,0.5,0.4375,0.5,0.4375,0.4375,0.5,0.5625,0.5625,0.5,0.5625,0.5625,0.5625,0.625,0.625,0.625,0.625,0.6875,0.5625,0.6875,0.5,0.6875,0.5,0.75,0.4375,0.75,0.4375,0.6875,0.5,0.8125,0.5625,0.75,0.5625,0.8125,0.5625,0.875,0.625,0.875,0.625,0.9375,0.5625,0.9375,0.5,0.9375,0.5,1,0.4375,1,0.4375,0.9375,0.75,0.0625,0.75,0,0.8125,0,0.8125,0.0625,0.8125,0.125,0.875,0.125,0.875,0.1875,0.8125,0.1875,0.75,0.1875,0.75,0.25,0.6875,0.25,0.6875,0.1875,0.25,0.0625,0.25,0,0.3125,0,0.3125,0.0625,0.3125,0.125,0.375,0.1875,0.3125,0.1875,0.25,0.1875,0.25,0.25,0.1875,0.25,0.1875,0.1875,0.375,0,0.4375,0,0.5,0.125,0.375,0.25,0.5,0.375,0.375,0.5,0.5,0.625,0.375,0.75,0.5,0.875,0.625,0,0.6875,0,0.75,0.125,0.125,0,0.1875,0,0.25,0.125,0.625,0.25,0.625,0.3125,0.625,0.5,0.375,0.4375,0.625,0.5625,0.625,0.75,0.375,0.6875,0.625,0.8125,0.625,1,0.5625,1,0.375,1,0.375,0.9375,0.875,0,0.875,0.0625,0.875,0.25,0.8125,0.25,0.3125,0.25,0.125,0.25,0.125,0.1875 + } + UVIndex: *768 { + a: 51,19,47,46,57,24,53,52,63,30,59,58,69,36,65,64,75,17,71,70,81,45,78,76,50,15,83,82,85,17,87,86,89,18,55,90,56,18,88,92,95,21,97,96,100,23,61,101,62,23,99,104,107,27,109,108,112,29,67,113,68,29,111,115,118,33,120,119,122,35,124,123,74,39,128,127,130,40,132,131,134,41,136,135,80,43,138,137,139,19,91,140,142,44,144,143,47,0,48,46,48,15,50,46,50,14,51,46,53,2,55,52,55,18,56,52,56,20,57,52,59,4,61,58,61,23,62,58,62,26,63,58,65,6,67,64,67,29,68,64,68,32,69,64,71,1,73,70,73,39,74,70,74,38,75,70,78,12,79,76,79,43,80,76,80,42,81,76,83,1,71,82,71,17,85,82,85,14,50,82,87,3,88,86,88,18,89,86,89,14,85,86,55,2,91,90,91,19,51,90,51,14,89,90,88,3,93,92,93,21,95,92,95,20,56,92,97,5,99,96,99,23,100,96,100,20,95,96,61,4,102,101,102,24,57,101,57,20,100,101,99,5,105,104,105,27,107,104,107,26,62,104,109,7,111,108,111,29,112,108,112,26,107,108,67,6,114,113,114,30,63,113,63,26,112,113,111,7,116,115,116,33,118,115,118,32,68,115,120,9,121,119,121,35,122,119,122,32,118,119,124,8,125,123,125,36,69,123,69,32,122,123,128,10,129,127,129,40,130,127,130,38,74,127,132,11,133,131,133,41,134,131,134,38,130,131,136,3,87,135,87,17,75,135,75,38,134,135,138,0,47,137,47,19,139,137,139,42,80,137,91,2,141,140,141,44,142,140,142,42,139,140,144,13,145,143,145,45,81,143,81,42,142,143,146,149,148,147,150,153,152,151,154,157,156,155,158,161,160,159,162,165,164,163,166,169,168,167,170,173,172,171,174,176,175,163,177,180,179,178,181,183,182,178,184,187,186,185,188,191,190,189,192,194,193,189,195,198,197,196,199,202,201,200,203,205,204,200,206,209,208,207,210,213,212,211,214,217,216,215,218,221,220,219,222,225,224,223,226,229,228,227,230,232,231,147,233,236,235,234,148,149,238,237,238,149,170,171,170,149,146,239,152,153,179,240,179,153,181,178,181,153,150,241,156,157,190,242,190,157,192,189,192,157,154,243,160,161,201,244,201,161,203,200,203,161,158,245,164,165,247,246,247,165,214,215,214,165,162,248,168,169,250,249,250,169,226,227,226,169,166,251,172,173,164,246,164,173,174,163,174,173,170,239,175,176,182,252,182,176,177,178,177,176,174,239, +179,180,231,240,231,180,146,147,146,180,177,239,182,183,253,252,253,183,184,185,184,183,181,241,186,187,193,254,193,187,188,189,188,187,184,241,190,191,255,242,255,191,150,151,150,191,188,241,193,194,256,254,256,194,195,196,195,194,192,243,197,198,204,257,204,198,199,200,199,198,195,243,201,202,258,244,258,202,154,155,154,202,199,243,204,205,259,257,259,205,206,207,206,205,203,245,208,209,261,260,261,209,210,211,210,209,206,245,212,213,263,262,263,213,158,159,158,213,210,245,216,217,265,264,265,217,218,219,218,217,214,248,220,221,267,266,267,221,222,223,222,221,218,248,224,225,175,252,175,225,162,163,162,225,222,248,228,229,148,237,148,229,230,147,230,229,226,251,231,232,268,240,268,232,233,234,233,232,230,251,235,236,270,269,270,236,166,167,166,236,233,251 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *384 { + a: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Model: 1827098352032, "Model::Cube2", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",-0.0104023897647858,0.00998288810253143,-0.0104375958442688 + P: "Lcl Scaling", "Lcl Scaling", "", "A",0.1,-0.1,0.1 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 1827098379872, "Model::Cube1", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",1.04023897647858,-0.998288810253143,1.04375958442688 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 1827098382192, "Model::Cube3", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",-0.0106711769104004,0.00998288810253143,0.0939023494720459 + P: "Lcl Scaling", "Lcl Scaling", "", "A",0.1,0.1,0.1 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 1827098384512, "Model::Cube1", "Mesh" { + Version: 232 + Properties70: { + P: "RotationPivot", "Vector3D", "Vector", "",-0.578102593944473,0.709856817059169,-0.892474638271642 + P: "ScalingOffset", "Vector3D", "Vector", "",0.168946330316482,-0.207450555573549,0.260819301999204 + P: "ScalingPivot", "Vector3D", "Vector", "",-0.747048924260949,0.917307372632704,-1.15329394027084 + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",1.04023897647858,-0.998288810253143,1.18067407608032 + P: "Lcl Scaling", "Lcl Scaling", "", "A",0.77384837213491,0.77384837213491,0.77384837213491 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Material: 1827074508720, "Material::Mat_Green", "" { + Version: 102 + ShadingModel: "lambert" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",0,1,0 + P: "DiffuseFactor", "Number", "", "A",0.800000011920929 + P: "TransparencyFactor", "Number", "", "A",1 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",0,0.800000011920929,0 + P: "Opacity", "double", "Number", "",1 + } + } + Material: 1827074501920, "Material::Mat_Red", "" { + Version: 102 + ShadingModel: "lambert" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",1,0,0 + P: "DiffuseFactor", "Number", "", "A",0.800000011920929 + P: "TransparencyFactor", "Number", "", "A",1 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",0.800000011920929,0,0 + P: "Opacity", "double", "Number", "",1 + } + } + AnimationStack: 1825586153728, "AnimStack::Take 001", "" { + Properties70: { + P: "LocalStart", "KTime", "Time", "",1924423250 + P: "LocalStop", "KTime", "Time", "",230930790000 + P: "ReferenceStart", "KTime", "Time", "",1924423250 + P: "ReferenceStop", "KTime", "Time", "",230930790000 + } + } + AnimationLayer: 1827070038960, "AnimLayer::BaseLayer", "" { + } +} + +; Object connections +;------------------------------------------------------------------ + +Connections: { + + ;Model::Cube2, Model::RootNode + C: "OO",1827098352032,0 + + ;Model::Cube3, Model::RootNode + C: "OO",1827098382192,0 + + ;AnimLayer::BaseLayer, AnimStack::Take 001 + C: "OO",1827070038960,1825586153728 + + ;Geometry::, Model::Cube2 + C: "OO",1827080157856,1827098352032 + + ;Material::Mat_Green, Model::Cube2 + C: "OO",1827074508720,1827098352032 + + ;Model::Cube1, Model::Cube2 + C: "OO",1827098379872,1827098352032 + + ;Geometry::, Model::Cube1 + C: "OO",1827080155296,1827098379872 + + ;Material::Mat_Green, Model::Cube1 + C: "OO",1827074508720,1827098379872 + + ;Geometry::, Model::Cube3 + C: "OO",1827080156320,1827098382192 + + ;Material::Mat_Red, Model::Cube3 + C: "OO",1827074501920,1827098382192 + + ;Model::Cube1, Model::Cube3 + C: "OO",1827098384512,1827098382192 + + ;Geometry::, Model::Cube1 + C: "OO",1827080139424,1827098384512 + + ;Material::Mat_Red, Model::Cube1 + C: "OO",1827074501920,1827098384512 +} +;Takes section +;---------------------------------------------------- + +Takes: { + Current: "Take 001" + Take: "Take 001" { + FileName: "Take_001.tak" + LocalTime: 1924423250,230930790000 + ReferenceTime: 1924423250,230930790000 + } +} diff --git a/test/models/FBX/cubes_with_names.fbx b/test/models/FBX/cubes_with_names.fbx new file mode 100644 index 000000000..203543ec8 --- /dev/null +++ b/test/models/FBX/cubes_with_names.fbx @@ -0,0 +1,852 @@ +; FBX 7.5.0 project file +; ---------------------------------------------------- + +FBXHeaderExtension: { + FBXHeaderVersion: 1003 + FBXVersion: 7500 + CreationTimeStamp: { + Version: 1000 + Year: 2019 + Month: 1 + Day: 7 + Hour: 16 + Minute: 17 + Second: 31 + Millisecond: 730 + } + Creator: "FBX SDK/FBX Plugins version 2018.1.1" + SceneInfo: "SceneInfo::GlobalInfo", "UserData" { + Type: "UserData" + Version: 100 + MetaData: { + Version: 100 + Title: "" + Subject: "" + Author: "" + Keywords: "" + Revision: "" + Comment: "" + } + Properties70: { + P: "DocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\cubes_with_names.fbx" + P: "SrcDocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\cubes_with_names.fbx" + P: "Original", "Compound", "", "" + P: "Original|ApplicationVendor", "KString", "", "", "Autodesk" + P: "Original|ApplicationName", "KString", "", "", "Maya" + P: "Original|ApplicationVersion", "KString", "", "", "201800" + P: "Original|DateTime_GMT", "DateTime", "", "", "07/01/2019 16:17:31.730" + P: "Original|FileName", "KString", "", "", "U:\Some\Absolute\Path\cubes_with_names.fbx" + P: "LastSaved", "Compound", "", "" + P: "LastSaved|ApplicationVendor", "KString", "", "", "Autodesk" + P: "LastSaved|ApplicationName", "KString", "", "", "Maya" + P: "LastSaved|ApplicationVersion", "KString", "", "", "201800" + P: "LastSaved|DateTime_GMT", "DateTime", "", "", "07/01/2019 16:17:31.730" + P: "Original|ApplicationActiveProject", "KString", "", "", "U:\Some\Absolute\Path" + } + } +} +GlobalSettings: { + Version: 1000 + Properties70: { + P: "UpAxis", "int", "Integer", "",1 + P: "UpAxisSign", "int", "Integer", "",1 + P: "FrontAxis", "int", "Integer", "",2 + P: "FrontAxisSign", "int", "Integer", "",1 + P: "CoordAxis", "int", "Integer", "",0 + P: "CoordAxisSign", "int", "Integer", "",1 + P: "OriginalUpAxis", "int", "Integer", "",1 + P: "OriginalUpAxisSign", "int", "Integer", "",1 + P: "UnitScaleFactor", "double", "Number", "",1 + P: "OriginalUnitScaleFactor", "double", "Number", "",1 + P: "AmbientColor", "ColorRGB", "Color", "",0,0,0 + P: "DefaultCamera", "KString", "", "", "Producer Perspective" + P: "TimeMode", "enum", "", "",11 + P: "TimeProtocol", "enum", "", "",2 + P: "SnapOnFrameMode", "enum", "", "",0 + P: "TimeSpanStart", "KTime", "Time", "",1924423250 + P: "TimeSpanStop", "KTime", "Time", "",384884650000 + P: "CustomFrameRate", "double", "Number", "",-1 + P: "TimeMarker", "Compound", "", "" + P: "CurrentTimeMarker", "int", "Integer", "",-1 + } +} + +; Documents Description +;------------------------------------------------------------------ + +Documents: { + Count: 1 + Document: 2359325563280, "", "Scene" { + Properties70: { + P: "SourceObject", "object", "", "" + P: "ActiveAnimStackName", "KString", "", "", "Take 001" + } + RootNode: 0 + } +} + +; Document References +;------------------------------------------------------------------ + +References: { +} + +; Object definitions +;------------------------------------------------------------------ + +Definitions: { + Version: 100 + Count: 13 + ObjectType: "GlobalSettings" { + Count: 1 + } + ObjectType: "AnimationStack" { + Count: 1 + PropertyTemplate: "FbxAnimStack" { + Properties70: { + P: "Description", "KString", "", "", "" + P: "LocalStart", "KTime", "Time", "",0 + P: "LocalStop", "KTime", "Time", "",0 + P: "ReferenceStart", "KTime", "Time", "",0 + P: "ReferenceStop", "KTime", "Time", "",0 + } + } + } + ObjectType: "AnimationLayer" { + Count: 1 + PropertyTemplate: "FbxAnimLayer" { + Properties70: { + P: "Weight", "Number", "", "A",100 + P: "Mute", "bool", "", "",0 + P: "Solo", "bool", "", "",0 + P: "Lock", "bool", "", "",0 + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BlendMode", "enum", "", "",0 + P: "RotationAccumulationMode", "enum", "", "",0 + P: "ScaleAccumulationMode", "enum", "", "",0 + P: "BlendModeBypass", "ULongLong", "", "",0 + } + } + } + ObjectType: "Geometry" { + Count: 4 + PropertyTemplate: "FbxMesh" { + Properties70: { + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BBoxMin", "Vector3D", "Vector", "",0,0,0 + P: "BBoxMax", "Vector3D", "Vector", "",0,0,0 + P: "Primary Visibility", "bool", "", "",1 + P: "Casts Shadows", "bool", "", "",1 + P: "Receive Shadows", "bool", "", "",1 + } + } + } + ObjectType: "Material" { + Count: 2 + PropertyTemplate: "FbxSurfaceLambert" { + Properties70: { + P: "ShadingModel", "KString", "", "", "Lambert" + P: "MultiLayer", "bool", "", "",0 + P: "EmissiveColor", "Color", "", "A",0,0,0 + P: "EmissiveFactor", "Number", "", "A",1 + P: "AmbientColor", "Color", "", "A",0.2,0.2,0.2 + P: "AmbientFactor", "Number", "", "A",1 + P: "DiffuseColor", "Color", "", "A",0.8,0.8,0.8 + P: "DiffuseFactor", "Number", "", "A",1 + P: "Bump", "Vector3D", "Vector", "",0,0,0 + P: "NormalMap", "Vector3D", "Vector", "",0,0,0 + P: "BumpFactor", "double", "Number", "",1 + P: "TransparentColor", "Color", "", "A",0,0,0 + P: "TransparencyFactor", "Number", "", "A",0 + P: "DisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "DisplacementFactor", "double", "Number", "",1 + P: "VectorDisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "VectorDisplacementFactor", "double", "Number", "",1 + } + } + } + ObjectType: "Model" { + Count: 4 + PropertyTemplate: "FbxNode" { + Properties70: { + P: "QuaternionInterpolate", "enum", "", "",0 + P: "RotationOffset", "Vector3D", "Vector", "",0,0,0 + P: "RotationPivot", "Vector3D", "Vector", "",0,0,0 + P: "ScalingOffset", "Vector3D", "Vector", "",0,0,0 + P: "ScalingPivot", "Vector3D", "Vector", "",0,0,0 + P: "TranslationActive", "bool", "", "",0 + P: "TranslationMin", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMax", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMinX", "bool", "", "",0 + P: "TranslationMinY", "bool", "", "",0 + P: "TranslationMinZ", "bool", "", "",0 + P: "TranslationMaxX", "bool", "", "",0 + P: "TranslationMaxY", "bool", "", "",0 + P: "TranslationMaxZ", "bool", "", "",0 + P: "RotationOrder", "enum", "", "",0 + P: "RotationSpaceForLimitOnly", "bool", "", "",0 + P: "RotationStiffnessX", "double", "Number", "",0 + P: "RotationStiffnessY", "double", "Number", "",0 + P: "RotationStiffnessZ", "double", "Number", "",0 + P: "AxisLen", "double", "Number", "",10 + P: "PreRotation", "Vector3D", "Vector", "",0,0,0 + P: "PostRotation", "Vector3D", "Vector", "",0,0,0 + P: "RotationActive", "bool", "", "",0 + P: "RotationMin", "Vector3D", "Vector", "",0,0,0 + P: "RotationMax", "Vector3D", "Vector", "",0,0,0 + P: "RotationMinX", "bool", "", "",0 + P: "RotationMinY", "bool", "", "",0 + P: "RotationMinZ", "bool", "", "",0 + P: "RotationMaxX", "bool", "", "",0 + P: "RotationMaxY", "bool", "", "",0 + P: "RotationMaxZ", "bool", "", "",0 + P: "InheritType", "enum", "", "",0 + P: "ScalingActive", "bool", "", "",0 + P: "ScalingMin", "Vector3D", "Vector", "",0,0,0 + P: "ScalingMax", "Vector3D", "Vector", "",1,1,1 + P: "ScalingMinX", "bool", "", "",0 + P: "ScalingMinY", "bool", "", "",0 + P: "ScalingMinZ", "bool", "", "",0 + P: "ScalingMaxX", "bool", "", "",0 + P: "ScalingMaxY", "bool", "", "",0 + P: "ScalingMaxZ", "bool", "", "",0 + P: "GeometricTranslation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricRotation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricScaling", "Vector3D", "Vector", "",1,1,1 + P: "MinDampRangeX", "double", "Number", "",0 + P: "MinDampRangeY", "double", "Number", "",0 + P: "MinDampRangeZ", "double", "Number", "",0 + P: "MaxDampRangeX", "double", "Number", "",0 + P: "MaxDampRangeY", "double", "Number", "",0 + P: "MaxDampRangeZ", "double", "Number", "",0 + P: "MinDampStrengthX", "double", "Number", "",0 + P: "MinDampStrengthY", "double", "Number", "",0 + P: "MinDampStrengthZ", "double", "Number", "",0 + P: "MaxDampStrengthX", "double", "Number", "",0 + P: "MaxDampStrengthY", "double", "Number", "",0 + P: "MaxDampStrengthZ", "double", "Number", "",0 + P: "PreferedAngleX", "double", "Number", "",0 + P: "PreferedAngleY", "double", "Number", "",0 + P: "PreferedAngleZ", "double", "Number", "",0 + P: "LookAtProperty", "object", "", "" + P: "UpVectorProperty", "object", "", "" + P: "Show", "bool", "", "",1 + P: "NegativePercentShapeSupport", "bool", "", "",1 + P: "DefaultAttributeIndex", "int", "Integer", "",-1 + P: "Freeze", "bool", "", "",0 + P: "LODBox", "bool", "", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",0,0,0 + P: "Lcl Rotation", "Lcl Rotation", "", "A",0,0,0 + P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1 + P: "Visibility", "Visibility", "", "A",1 + P: "Visibility Inheritance", "Visibility Inheritance", "", "",1 + } + } + } +} + +; Object properties +;------------------------------------------------------------------ + +Objects: { + Geometry: 2358377979296, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 2358377961872, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 2358377982464, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,0.5,0.5,0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5 + } + PolygonVertexIndex: *24 { + a: 0,1,3,-3,2,3,5,-5,4,5,7,-7,6,7,1,-1,1,7,5,-4,6,0,2,-5 + } + Edges: *12 { + a: 0,1,2,3,5,6,7,9,10,11,13,15 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: 1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,-0,1,0,-0,1,0,-0,1,0,-0,1 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *28 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25 + } + UVIndex: *24 { + a: 0,1,3,2,2,3,5,4,4,5,7,6,6,7,9,8,1,10,11,3,12,0,2,13 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Geometry: 2358377979824, "Geometry::", "Mesh" { + Vertices: *588 { + a: -0.499999970197678,-0.5,0.5,0.500000059604645,-0.5,0.5,-0.499999970197678,0.5,0.5,0.500000059604645,0.5,0.5,-0.499999970197678,0.5,-0.49999988079071,0.500000059604645,0.5,-0.49999988079071,-0.499999970197678,-0.5,-0.49999988079071,0.500000059604645,-0.5,-0.49999988079071,0,0,0.5,0,-0.5,0.5,0.500000059604645,0,0.5,0,0.5,0.5,-0.499999970197678,0,0.5,0,0.5,1.19209289550781e-07,0.500000059604645,0.5,1.19209289550781e-07,0,0.5,-0.49999988079071,-0.499999970197678,0.5,1.19209289550781e-07,0,0,-0.49999988079071,0.500000059604645,0,-0.49999988079071,0,-0.5,-0.49999988079071,-0.499999970197678,0,-0.49999988079071,0,-0.5,1.19209289550781e-07,0.500000059604645,-0.5,1.19209289550781e-07,-0.499999970197678,-0.5,1.19209289550781e-07,0.500000059604645,0,1.19209289550781e-07,-0.499999970197678,0,1.19209289550781e-07,-0.25,-0.25,0.5,-0.499999970197678,-0.25,0.5,-0.25,-0.5,0.5,0,-0.25,0.5,-0.25,0,0.5,-0.25,0.5,0.25,-0.499999970197678,0.5,0.25,-0.25,0.5,0.5,0,0.5,0.25,-0.25,0.5,1.19209289550781e-07,-0.25,0.25,-0.49999988079071,-0.499999970197678,0.25,-0.49999988079071,-0.25,0.5,-0.49999988079071,0,0.25,-0.49999988079071,-0.25,0,-0.49999988079071,-0.25,-0.5,-0.24999988079071,-0.499999970197678,-0.5,-0.24999988079071,-0.25,-0.5,-0.49999988079071,0,-0.5,-0.24999988079071,-0.25,-0.5,1.19209289550781e-07,0.500000059604645,-0.25,0.25,0.500000059604645,-0.25,0.5,0.500000059604645,-0.5,0.25,0.500000059604645,-0.25,1.19209289550781e-07,0.500000059604645,0,0.25,-0.499999970197678,-0.25,-0.24999988079071,-0.499999970197678,-0.25,-0.49999988079071,-0.499999970197678,-0.25,1.19209289550781e-07,-0.499999970197678,0,-0.24999988079071,0.250000059604645,-0.25,0.5,0.250000059604645,-0.5,0.5,0.250000059604645,0,0.5,0.250000059604645,0.25,0.5,0.500000059604645,0.25,0.5,0.250000059604645,0.5,0.5,0,0.25,0.5,-0.25,0.25,0.5,-0.499999970197678,0.25,0.5,0.250000059604645,0.5,0.25,0.500000059604645,0.5,0.25,0.250000059604645,0.5,1.19209289550781e-07,0.250000059604645,0.5,-0.24999988079071,0.500000059604645,0.5,-0.24999988079071,0.250000059604645,0.5,-0.49999988079071, +0,0.5,-0.24999988079071,-0.25,0.5,-0.24999988079071,-0.499999970197678,0.5,-0.24999988079071,0.250000059604645,0.25,-0.49999988079071,0.500000059604645,0.25,-0.49999988079071,0.250000059604645,0,-0.49999988079071,0.250000059604645,-0.25,-0.49999988079071,0.500000059604645,-0.25,-0.49999988079071,0.250000059604645,-0.5,-0.49999988079071,0,-0.25,-0.49999988079071,-0.25,-0.25,-0.49999988079071,0.250000059604645,-0.5,-0.24999988079071,0.500000059604645,-0.5,-0.24999988079071,0.250000059604645,-0.5,1.19209289550781e-07,0.250000059604645,-0.5,0.25,0,-0.5,0.25,-0.25,-0.5,0.25,-0.499999970197678,-0.5,0.25,0.500000059604645,-0.25,-0.24999988079071,0.500000059604645,0,-0.24999988079071,0.500000059604645,0.25,-0.24999988079071,0.500000059604645,0.25,1.19209289550781e-07,0.500000059604645,0.25,0.25,-0.499999970197678,-0.25,0.25,-0.499999970197678,0,0.25,-0.499999970197678,0.25,0.25,-0.499999970197678,0.25,1.19209289550781e-07,-0.499999970197678,0.25,-0.24999988079071,-0.594913899898529,0,0.594913899898529,-0.152911216020584,0,0.714658200740814,-0.594913899898529,-0.152911216020584,0.594913899898529,-0.152911216020584,-0.152911216020584,0.714658200740814,-0.594913899898529,0.594913899898529,7.29137497046395e-08,-0.152911216020584,0.714658200740814,7.29137497046395e-08,-0.594913899898529,0.594913899898529,0.152911216020584,-0.152911216020584,0.714658200740814,0.152911216020584,-0.594913899898529,0,-0.594913899898529,-0.152911216020584,0,-0.714658200740814,-0.594913899898529,0.152911216020584,-0.594913899898529,-0.152911216020584,0.152911216020584,-0.714658200740814,-0.594913899898529,-0.594913899898529,7.29137497046395e-08,-0.152911216020584,-0.714658200740814,7.29137497046395e-08,-0.594913899898529,-0.594913899898529,-0.152911216020584,-0.152911216020584,-0.714658200740814,-0.152911216020584,0.594913899898529,0,0.594913899898529,0.714658200740814,0,0.152911216020584,0.594913899898529,-0.152911216020584,0.594913899898529,0.714658200740814,-0.152911216020584,0.152911216020584,-0.714658200740814,0,-0.152911216020584,-0.594913899898529,-0.152911216020584,-0.594913899898529, +-0.714658200740814,-0.152911216020584,-0.152911216020584,8.62321627254444e-17,-0.594913899898529,0.594913899898529,8.62321627254444e-17,-0.152911216020584,0.714658200740814,0.152911230921745,-0.594913899898529,0.594913899898529,0.152911230921745,-0.152911216020584,0.714658200740814,0.152911230921745,0,0.714658200740814,0.594913899898529,0.152911216020584,0.594913899898529,0.152911230921745,0.152911216020584,0.714658200740814,8.62321627254444e-17,0.594913899898529,0.594913899898529,8.62321627254444e-17,0.152911216020584,0.714658200740814,-0.152911216020584,0.594913899898529,0.594913899898529,-0.152911216020584,0.152911216020584,0.714658200740814,8.62321627254444e-17,0.714658200740814,0.152911216020584,0.152911230921745,0.594913899898529,0.594913899898529,0.152911230921745,0.714658200740814,0.152911216020584,0.594913899898529,0.594913899898529,7.29137497046395e-08,0.152911230921745,0.714658200740814,7.29137497046395e-08,0.594913899898529,0.594913899898529,-0.152911216020584,0.152911230921745,0.714658200740814,-0.152911216020584,8.62321627254444e-17,0.594913899898529,-0.594913899898529,8.62321627254444e-17,0.714658200740814,-0.152911216020584,-0.152911216020584,0.594913899898529,-0.594913899898529,-0.152911216020584,0.714658200740814,-0.152911216020584,8.62321627254444e-17,0.152911216020584,-0.714658200740814,0.152911230921745,0.594913899898529,-0.594913899898529,0.152911230921745,0.152911216020584,-0.714658200740814,0.594913899898529,0,-0.594913899898529,0.152911230921745,0,-0.714658200740814,0.594913899898529,-0.152911216020584,-0.594913899898529,0.152911230921745,-0.152911216020584,-0.714658200740814,8.62321627254444e-17,-0.594913899898529,-0.594913899898529,8.62321627254444e-17,-0.152911216020584,-0.714658200740814,-0.152911216020584,-0.594913899898529,-0.594913899898529,-0.152911216020584,-0.152911216020584,-0.714658200740814,8.62321627254444e-17,-0.714658200740814,-0.152911216020584,0.152911230921745,-0.594913899898529,-0.594913899898529,0.152911230921745,-0.714658200740814,-0.152911216020584,0.594913899898529,-0.594913899898529,7.29137497046395e-08, +0.152911230921745,-0.714658200740814,7.29137497046395e-08,0.594913899898529,-0.594913899898529,0.152911216020584,0.152911230921745,-0.714658200740814,0.152911216020584,8.62321627254444e-17,-0.714658200740814,0.152911216020584,-0.152911216020584,-0.594913899898529,0.594913899898529,-0.152911216020584,-0.714658200740814,0.152911216020584,0.714658200740814,-0.152911216020584,7.29137497046395e-08,0.594913899898529,-0.594913899898529,-0.152911216020584,0.714658200740814,-0.152911216020584,-0.152911216020584,0.714658200740814,0,-0.152911216020584,0.594913899898529,0.152911216020584,-0.594913899898529,0.714658200740814,0.152911216020584,-0.152911216020584,0.714658200740814,0.152911216020584,7.29137497046395e-08,0.594913899898529,0.594913899898529,0.152911216020584,0.714658200740814,0.152911216020584,0.152911216020584,-0.714658200740814,-0.152911216020584,7.29137497046395e-08,-0.594913899898529,-0.594913899898529,0.152911216020584,-0.714658200740814,-0.152911216020584,0.152911216020584,-0.714658200740814,0,0.152911216020584,-0.594913899898529,0.152911216020584,0.594913899898529,-0.714658200740814,0.152911216020584,0.152911216020584,-0.714658200740814,0.152911216020584,7.29137497046395e-08,-0.594913899898529,0.594913899898529,-0.152911216020584,-0.714658200740814,0.152911216020584,-0.152911216020584,-0.541863918304443,-0.541864037513733,0.541863918304443,8.62321627254444e-17,0,0.714658200740814,-0.541863918304443,0.541863918304443,0.541863918304443,8.62321627254444e-17,0.714658200740814,7.29137497046395e-08,-0.541863918304443,0.541863918304443,-0.541863799095154,8.62321627254444e-17,0,-0.714658200740814,-0.541863918304443,-0.541864037513733,-0.541863799095154,8.62321627254444e-17,-0.714658200740814,7.29137497046395e-08,0.541863977909088,-0.541864037513733,0.541863918304443,0.714658200740814,0,7.29137497046395e-08,-0.714658200740814,0,7.29137497046395e-08,0.541863977909088,0.541863918304443,0.541863918304443,0.541863977909088,0.541863918304443,-0.541863799095154,0.541863977909088,-0.541864037513733,-0.541863799095154 + } + PolygonVertexIndex: *768 { + a: 99,98,100,-102,103,102,104,-106,107,106,108,-110,111,110,112,-114,115,114,116,-118,118,106,119,-121,122,121,123,-125,125,114,126,-128,129,128,130,-132,132,128,133,-135,136,135,137,-139,140,139,141,-143,143,139,144,-146,147,146,148,-150,151,150,152,-154,154,150,155,-157,158,157,159,-161,161,121,162,-164,164,157,165,-167,167,146,168,-170,170,135,171,-173,173,110,174,-176,176,98,177,-179,179,102,180,-182,100,182,162,-102,162,121,122,-102,122,183,99,-102,104,184,130,-106,130,128,132,-106,132,185,103,-106,108,186,141,-110,141,139,143,-110,143,187,107,-110,112,188,152,-114,152,150,154,-114,154,189,111,-114,116,190,159,-118,159,157,164,-118,164,191,115,-118,119,188,112,-121,112,110,173,-121,173,192,118,-121,123,190,116,-125,116,114,125,-125,125,183,122,-125,126,193,133,-128,133,128,129,-128,129,183,125,-128,130,184,177,-132,177,98,99,-132,99,183,129,-132,133,193,171,-135,171,135,136,-135,136,185,132,-135,137,194,144,-139,144,139,140,-139,140,185,136,-139,141,186,180,-143,180,102,103,-143,103,185,140,-143,144,194,168,-146,168,146,147,-146,147,187,143,-146,148,195,155,-150,155,150,151,-150,151,187,147,-150,152,188,119,-154,119,106,107,-154,107,187,151,-154,155,195,165,-157,165,157,158,-157,158,189,154,-157,159,190,123,-161,123,121,161,-161,161,189,158,-161,162,182,174,-164,174,110,111,-164,111,189,161,-164,165,195,148,-167,148,146,167,-167,167,191,164,-167,168,194,137,-170,137,135,170,-170,170,191,167,-170,171,193,126,-173,126,114,115,-173,115,191,170,-173,174,182,100,-176,100,98,176,-176,176,192,173,-176,177,184,104,-179,104,102,179,-179,179,192,176,-179,180,186,108,-182,108,106,118,-182,118,192,179,-182,30,26,27,-13,35,31,32,-17,40,36,37,-21,45,41,42,-24,50,46,47,-11,54,51,52,-21,29,55,56,-10,57,58,59,-11,61,62,33,-12,34,64,60,-12,66,67,68,-15,70,71,38,-16,39,73,69,-16,75,76,77,-19,79,80,43,-20,44,81,78,-20,83,84,48,-23,85,86,28,-10,49,88,82,-23,89,90,74,-19,91,92,65,-15,53,93,87,-24,94,95,63,-13,96,97,72,-17,27,26,28,-1,28,26,29,-10,29,26,30,-9,32,31,33,-3,33,31,34,-12,34,31,35,-14,37,36,38,-5,38,36,39, +-16,39,36,40,-18,42,41,43,-7,43,41,44,-20,44,41,45,-22,47,46,48,-2,48,46,49,-23,49,46,50,-25,52,51,42,-7,42,51,53,-24,53,51,54,-26,56,55,47,-2,47,55,57,-11,57,55,29,-9,59,58,60,-4,60,58,61,-12,61,58,57,-9,33,62,63,-3,63,62,30,-13,30,62,61,-9,60,64,65,-4,65,64,66,-15,66,64,34,-14,68,67,69,-6,69,67,70,-16,70,67,66,-14,38,71,72,-5,72,71,35,-17,35,71,70,-14,69,73,74,-6,74,73,75,-19,75,73,39,-18,77,76,78,-8,78,76,79,-20,79,76,75,-18,43,80,52,-7,52,80,40,-21,40,80,79,-18,78,81,82,-8,82,81,83,-23,83,81,44,-22,48,84,56,-2,56,84,85,-10,85,84,83,-22,28,86,87,-1,87,86,45,-24,45,86,85,-22,82,88,77,-8,77,88,89,-19,89,88,49,-25,74,90,68,-6,68,90,91,-15,91,90,89,-25,65,92,59,-4,59,92,50,-11,50,92,91,-25,87,93,27,-1,27,93,94,-13,94,93,53,-26,63,95,32,-3,32,95,96,-17,96,95,94,-26,72,97,37,-5,37,97,54,-21,54,97,96,-26 + } + Edges: *384 { + a: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,102,104,105,108,109,110,114,116,117,120,121,122,126,128,129,132,133,134,138,140,141,144,145,146,150,152,153,156,158,162,164,165,168,170,174,176,180,181,182,186,188,193,194,198,205,206,210,212,216,217,218,222,224,229,230,234,241,242,246,248,252,253,254,258,260,266,270,277,278,282,284,290,294,296,301,302,306,314,318,320,326,330,332,338,342,350,354,356,362,366,368,374,378,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,481,482,483,485,490,491,493,494,495,497,502,503,505,506,507,509,514,515,517,518,519,521,526,527,529,530,531,533,538,539,541,543,545,550,551,553,555,557,563,565,566,567,569,575,577,578,581,589,590,593,599,601,602,603,605,611,613,614,617,625,626,629,635,637,638,639,641,647,649,653,661,662,665,671,673,677,683,685,686,689,697,701,707,709,713,719,721,725,733,737,743,745,749,755,757,761 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *2304 { + a: -0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.26148721575737,0.965207040309906,0,-0.26148721575737,0.965207040309906,0,-0.26148721575737,0.965207040309906,0,-0.26148721575737,0.965207040309906,0,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0,0.965207040309906,0.261487185955048,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0.261487126350403,0,-0.965206980705261, +0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0,-0.965207040309906,-0.261487185955048,0.26148721575737,-0.965207040309906,0,0.26148721575737,-0.965207040309906,0,0.26148721575737,-0.965207040309906,0,0.26148721575737,-0.965207040309906,0,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,-0.261487066745758,0,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.965206980705261,0.261487066745758,0,-0.211917281150818,-0.211917445063591,0.954034626483917,0,0,1,-0.211917281150818,-0.21191743016243,0.954034626483917,-0.211917266249657,-0.211917445063591,0.954034626483917,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,-0.211917445063591,0.954034626483917,0.211917281150818, +0,1,0,-0.211917445063591,0.954034626483917,0.211917281150818,-0.211917445063591,0.954034626483917,0.211917266249657,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,1,0,0,1,0,0,1,0,0,1,0,-0.211917623877525,0.211917608976364,-0.954034626483917,0,0,-1,-0.211917623877525,0.211917608976364,-0.954034626483917,-0.211917623877525,0.211917594075203,-0.954034626483917,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.211917355656624,-0.954034745693207,-0.211917355656624,0,-1,0,-0.211917325854301,-0.954034686088562,-0.211917325854301,-0.211917355656624,-0.954034686088562,-0.211917355656624,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.954034745693207,-0.211917281150818,0.211917340755463,1,0,0,0.954034745693207,-0.211917281150818,0.211917370557785,0.954034626483917,-0.211917236447334,0.211917296051979,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,1,0,0,1,0,0,1,0,0,1,0,0,-0.954034686088562,-0.211917355656624,-0.211917459964752,-1,0,0,-0.954034626483917,-0.211917325854301,-0.211917445063591,-0.954034686088562,-0.211917355656624,-0.211917474865913,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-0.965206980705261,-0.261487066745758,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0.211917281150818,-0.211917400360107,0.954034626483917,0,0,1,0.211917266249657,-0.211917415261269,0.954034626483917,0.211917266249657,-0.211917415261269,0.954034626483917,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261,0.261487126350403,0,0.965206980705261, +0,0,1,0,0,1,0,0,1,0,0,1,0.211917296051979,0.211917415261269,0.954034626483917,0,0,1,0.211917296051979,0.211917415261269,0.954034626483917,0.211917281150818,0.211917415261269,0.954034626483917,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0.261487185955048,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,-0.211917281150818,0.211917445063591,0.954034626483917,0,0,1,-0.211917281150818,0.211917445063591,0.954034626483917,-0.211917266249657,0.211917445063591,0.954034626483917,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,-0.261487126350403,0,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0.211917445063591,0.954034626483917,0.211917445063591,0,1,0,0.211917445063591,0.954034686088562,0.211917445063591,0.211917445063591,0.954034626483917,0.211917445063591,0.26148721575737,0.965207040309906,0,0.26148721575737,0.965207040309906,0,0.26148721575737,0.965207040309906,0,0.26148721575737,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,0,0.211917445063591,0.954034626483917,-0.211917489767075,0,1,0,0.211917459964752,0.954034686088562,-0.211917519569397,0.211917474865913,0.954034686088562,-0.211917504668236,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,0.965207040309906,-0.261487185955048,0,1,0,0,1,0,0,1,0,0,1,0,-0.211917459964752,0.954034686088562,-0.211917340755463,0,1,0,-0.211917445063591,0.954034626483917,-0.21191731095314,-0.211917489767075,0.954034686088562,-0.211917355656624,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,-0.261487185955048,0.965207040309906,0,0,1,0,0,1,0,0,1,0,0,1,0,0.211917638778687,0.211917608976364,-0.954034626483917,0,0,-1,0.211917608976364,0.211917564272881,-0.954034566879272,0.211917623877525,0.211917608976364,-0.954034626483917,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261, +0.261487126350403,0,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0.211917608976364,-0.211917564272881,-0.954034626483917,0,0,-1,0.211917623877525,-0.211917579174042,-0.954034626483917,0.211917623877525,-0.211917549371719,-0.954034626483917,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,-0.261487185955048,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.211917623877525,-0.211917579174042,-0.954034626483917,0,0,-1,-0.211917579174042,-0.211917534470558,-0.954034566879272,-0.211917623877525,-0.211917549371719,-0.954034626483917,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,-0.261487126350403,0,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0.211917340755463,-0.954034686088562,-0.211917519569397,0,-1,0,0.211917325854301,-0.954034626483917,-0.211917489767075,0.211917325854301,-0.954034686088562,-0.211917489767075,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0.261487185955048,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.211917281150818,-0.954034626483917,0.211917445063591,0,-1,0,0.211917296051979,-0.954034626483917,0.211917445063591,0.211917266249657,-0.954034626483917,0.211917445063591,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-0.965207040309906,0.261487185955048,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.211917325854301,-0.954034745693207,0.211917325854301,0,-1,0,-0.211917325854301,-0.954034745693207,0.211917325854301,-0.211917281150818,-0.954034686088562,0.211917281150818,-0.26148721575737,-0.965207040309906,0,-0.26148721575737,-0.965207040309906,0,-0.26148721575737,-0.965207040309906,0,-0.26148721575737,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0.954034626483917,-0.211917325854301,-0.211917400360107,1,0,0,0.954034686088562,-0.211917340755463,-0.211917400360107,0.954034686088562,-0.211917355656624,-0.21191743016243,0.965206980705261,0,-0.261487185955048, +0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,0.965206980705261,0,-0.261487185955048,1,0,0,1,0,0,1,0,0,1,0,0,0.954034686088562,0.211917370557785,-0.211917489767075,1,0,0,0.954034686088562,0.211917355656624,-0.211917445063591,0.954034626483917,0.211917355656624,-0.211917445063591,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,0.965206980705261,0.261487066745758,0,1,0,0,1,0,0,1,0,0,1,0,0,0.954034626483917,0.211917296051979,0.211917385458946,1,0,0,0.954034626483917,0.211917296051979,0.211917385458946,0.954034745693207,0.211917296051979,0.211917385458946,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,0.965206980705261,0,0.261487185955048,1,0,0,1,0,0,1,0,0,1,0,0,-0.954034626483917,-0.211917251348495,0.211917400360107,-1,0,0,-0.954034626483917,-0.211917266249657,0.211917400360107,-0.954034626483917,-0.211917251348495,0.211917400360107,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-0.965206980705261,0,0.261487185955048,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.954034626483917,0.211917281150818,0.211917445063591,-1,0,0,-0.954034626483917,0.211917281150818,0.211917445063591,-0.954034626483917,0.211917266249657,0.211917445063591,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-0.965206980705261,0.261487126350403,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.954034686088562,0.211917385458946,-0.211917549371719,-1,0,0,-0.954034686088562,0.211917370557785,-0.211917534470558,-0.954034626483917,0.211917355656624,-0.211917504668236,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-0.965206980705261,0,-0.261487185955048,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0, +1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0, +-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0 + } + NormalsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *2304 { + a: 0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,0,0.965206921100616,0.261487156152725,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.965206980705261,-0.261487185955048,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0.261487156152725,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.261487126350403,-0.965206980705261,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-0.965206921100616,-0.261487156152725,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.965206980705261,0.261487185955048,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,-0.261487156152725,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0, +0,1,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,0.261487066745758,0.965206980705261,0,-0.0554696954786777,0.977241098880768,0.204750895500183,0.0677256807684898,0.997704029083252,-0,0.0995207726955414,0.966452240943909,0.236782029271126,0.022095151245594,0.974918127059937,0.221464186906815,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,0.965206980705261,0.261487185955048,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0554696545004845,0.204750746488571,-0.977241158485413,0.0677258297801018,0,-0.997703969478607,0.0995210781693459,0.23678195476532,-0.966452240943909,0.0220953319221735,0.221464082598686,-0.974918246269226,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0.261487126350403,-0.965206980705261,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0554697290062904,-0.977241039276123,-0.204751029610634,0.0677258297801018,-0.997703969478607,0,0.0995209515094757,-0.966452121734619,-0.236782252788544,0.0220952276140451,-0.974918127059937,-0.221464350819588,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-0.965206980705261,-0.261487185955048,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,-0.0554696619510651,-0.204750776290894,0.977241098880768,0.0677259787917137,0,0.997703969478607,0.0995214134454727,-0.236782014369965,0.966452121734619,0.0220954976975918,-0.221464157104492,0.974918186664581,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0.20475073158741,0.977241218090057,0.0554696507751942,0,0.997704029083252,-0.0677256807684898,0.236781880259514,0.966452300548553,-0.0995208472013474,0.221463993191719,0.974918186664581,-0.0220952145755291,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0, +-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.204750791192055,0.977241098880768,-0.0554696619510651,0,0.997704029083252,0.0677257031202316,-0.236781939864159,0.966452240943909,0.099520817399025,-0.221464112401009,0.974918246269226,0.022095188498497,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0,-0.099520780146122,0.966452240943909,0.236781999468803,-0.0677256733179092,0.997704029083252,0,0.0554696880280972,0.977241098880768,0.204750865697861,-0.022095151245594,0.974918127059937,0.221464157104492,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0554696880280972,0.977241098880768,-0.204750865697861,0.0677258223295212,0.997703969478607,-0,0.0995210558176041,0.966452181339264,-0.236782059073448,0.0220952890813351,0.974918246269226,-0.221464201807976,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,0.965206921100616,-0.261487156152725,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0995210707187653,0.966452240943909,-0.236782118678093,-0.0677258297801018,0.997703969478607,0,0.0554696954786777,0.977241098880768,-0.204750895500183,-0.0220952928066254,0.974918186664581,-0.221464231610298,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0.0995210558176041,0.236782118678093,-0.966452240943909,-0.0677258223295212,0,-0.997703969478607,0.0554696880280972,0.204750880599022,-0.977241098880768,-0.0220952853560448,0.221464216709137,-0.974918127059937,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0554697066545486,-0.204750955104828,-0.977241158485413,0.0677259713411331,0,-0.997703969478607,0.0995213389396667,-0.236782237887383,-0.966452181339264,0.0220954176038504,-0.221464291214943,-0.974918127059937,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,-0.261487156152725,-0.965206921100616,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0995213687419891,-0.236782059073448,-0.966452181339264, +-0.0677259787917137,0,-0.997703969478607,0.0554696545004845,-0.204750776290894,-0.977241158485413,-0.0220954604446888,-0.221464172005653,-0.974918246269226,0,0,-1,0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.0995209366083145,-0.966452121734619,-0.236782252788544,-0.0677258223295212,-0.997703969478607,-0,0.0554697290062904,-0.977241098880768,-0.204751014709473,-0.0220952201634645,-0.974918127059937,-0.221464365720749,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,-0.0554697252810001,-0.977241158485413,0.204751014709473,0.0677256733179092,-0.997704029083252,0,0.099520668387413,-0.966452181339264,0.236782178282738,0.0220950860530138,-0.974918127059937,0.221464276313782,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-0.965206921100616,0.261487156152725,0,-1,0,0,-1,0,0,-1,-0,0,-1,0,-0.0995206832885742,-0.966452181339264,0.236782178282738,-0.0677256807684898,-0.997704029083252,-0,0.0554697178304195,-0.977241098880768,0.20475098490715,-0.0220950935035944,-0.974918127059937,0.221464276313782,0,-1,-0,0,-1,-0,-0,-1,0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0.0995213836431503,-0.23678220808506,0.966452121734619,-0.0677259713411331,0,0.997703969478607,0.0554697066545486,-0.204750940203667,0.977241098880768,-0.0220954623073339,-0.221464291214943,0.974918186664581,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0.0554696954786777,0.204750895500183,0.977241098880768,0.0677258223295212,0,0.997703969478607,0.0995211154222488,0.236782103776932,0.966452181339264,0.0220953226089478,0.221464246511459,0.974918186664581,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0.261487156152725,0.965206921100616,0,0,1,0,0,1,0,0,1,0,0,1,-0.0995211452245712,0.23678195476532,0.966452181339264,-0.0677258297801018,0,0.997703969478607,0.0554696656763554,0.204750776290894,0.977241218090057,-0.022095363587141,0.221464082598686,0.974918246269226,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0.236781939864159,0.966452240943909,0.0995208621025085, +-0,0.997704029083252,0.0677257031202316,0.204750806093216,0.977241158485413,-0.0554696656763554,0.221464112401009,0.974918186664581,0.0220951996743679,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0.204750806093216,0.977241098880768,0.0554696694016457,0,0.997703969478607,-0.0677258521318436,-0.236782044172287,0.966452240943909,-0.0995211452245712,-0.221464172005653,0.974918246269226,-0.0220953542739153,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,-0.261487066745758,0.965206980705261,0,0,1,-0,-0,1,0,-0,1,0,-0,1,0,-0.236781984567642,0.966452300548553,0.09952113032341,-0,0.997703969478607,0.0677258297801018,-0.204750761389732,0.977241158485413,-0.0554696582257748,-0.221464067697525,0.974918246269226,0.0220953486859798,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,-0,-0,1,0,-0.236781880259514,0.966452360153198,-0.0995208248496056,0,0.997704029083252,-0.0677256807684898,-0.20475073158741,0.977241158485413,0.0554696470499039,-0.221464022994041,0.974918246269226,-0.0220951903611422,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0.204750746488571,0.977241158485413,-0.0554696545004845,0,0.997703969478607,0.0677258297801018,0.23678195476532,0.966452240943909,0.0995210781693459,0.221464082598686,0.974918246269226,0.0220953319221735,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0,1,0,0,1,0,0,1,0,0,1,0,0.236782073974609,0.966452240943909,-0.0995211005210876,0,0.997703969478607,-0.0677258521318436,0.204750806093216,0.977241098880768,0.0554696656763554,0.221464142203331,0.974918186664581,-0.0220953188836575,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1, +0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-1,-0,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1, +-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0 + } + BinormalsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *2304 { + a: 0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965207040309906,0.26148721575737,0,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.965206980705261,-0.261487156152725,-0,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,0.965206980705261,-0.261487156152725,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0.26148721575737,-0,0.965207040309906, +0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.97571212053299,0.00952975451946259,0.218849271535873,0.997704029083252,-0.0677256807684898,0,0.972207129001617,-0.145124465227127,0.183717742562294,0.977037787437439,-0.0680116266012192,0.201919630169868,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,0.218849420547485,-0.0095297135412693,0.997703969478607,0,0.0677258297801018,0.972207069396973,0.183717846870422,0.145124778151512,0.977037727832794,0.20191977918148,0.0680118054151535,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.975712060928345,-0.00952969118952751,-0.218849584460258,0.997703969478607,0.0677258297801018,0,0.972207009792328,0.145124763250351,-0.183717995882034,0.977037727832794,0.0680118054151535,-0.201919928193092,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0.97571212053299,-0.218849301338196,0.00952974148094654,0.997703969478607,0,-0.0677259787917137,0.972207069396973,-0.183717638254166,-0.145125105977058,0.977037727832794,-0.201919630169868,-0.068011961877346,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.218849286437035,0.00952974148094654,-0.97571212053299,0,-0.0677256807684898,-0.997704029083252,0.183717831969261,-0.145124509930611,-0.972207069396973,0.201919674873352,-0.0680116564035416,-0.977037787437439,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.218849420547485,0.0095297172665596,0.97571212053299,0,-0.0677257031202316,0.997704029083252,-0.183717906475067,-0.145124524831772,0.972207069396973,-0.201919823884964,-0.068011686205864,0.977037727832794,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.972207129001617,0.145124465227127,-0.183717742562294,0.997704029083252,0.0677256733179092,0,0.97571212053299,-0.00952975824475288,-0.218849256634712,0.977037787437439,0.0680116191506386,-0.201919630169868,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403, +1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,0.00952975172549486,-0.218849286437035,0.997703969478607,-0.0677258223295212,0,0.972207069396973,-0.14512474834919,-0.183717682957649,0.977037847042084,-0.0680117681622505,-0.20191964507103,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,0.972207069396973,0.14512474834919,0.183717668056488,0.997703969478607,0.0677258297801018,0,0.97571212053299,-0.00952975451946259,0.218849271535873,0.977037847042084,0.0680117756128311,0.201919630169868,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,0.965206980705261,-0,0.261487126350403,1,-0,-0,1,-0,0,1,-0,0,1,-0,0,0.972207069396973,-0.183717831969261,-0.145124778151512,0.997703969478607,0,-0.0677258223295212,0.97571212053299,-0.218849405646324,0.00952972564846277,0.977037727832794,-0.20191977918148,-0.0680117979645729,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,0.965207040309906,-0.26148721575737,-0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0.97571212053299,-0.218849420547485,-0.0095297247171402,0.997703969478607,0,0.0677259713411331,0.972207009792328,-0.183717757463455,0.145125061273575,0.977037727832794,-0.201919749379158,0.0680119395256042,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,0.972207009792328,0.183717772364616,-0.145125061273575,0.997703969478607,0,-0.0677259787917137,0.97571212053299,0.218849420547485,0.00952971447259188,0.977037727832794,0.20191977918148,-0.0680119544267654,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,-0,0.965206980705261,0.261487156152725,0,1,-0,0,1,0,0,1,0,0,1,0,0,0.972207009792328,-0.14512474834919,0.183718010783195,0.997703969478607,-0.0677258223295212,0,0.975712060928345,0.00952969118952751,0.218849584460258,0.977037727832794,-0.0680117979645729,0.201919928193092,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403,0.965206980705261,0,0.261487126350403, +1,-0,0,1,-0,0,1,-0,0,1,-0,0,0.975712060928345,-0.00952969398349524,0.218849569559097,0.997704029083252,0.0677256733179092,0,0.972207069396973,0.145124465227127,0.18371807038784,0.977037727832794,0.0680116564035416,0.201919972896576,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0.972207069396973,-0.145124480128288,-0.183718055486679,0.997704029083252,-0.0677256807684898,0,0.975712060928345,0.00952969398349524,-0.218849569559097,0.977037727832794,-0.0680116638541222,-0.201919972896576,0.965206980705261,0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,0.965206980705261,-0,-0.261487126350403,0.965206980705261,0,-0.261487126350403,1,0,0,1,0,0,1,0,0,1,0,0,0.972207069396973,0.183717623353004,0.145125105977058,0.997703969478607,0,0.0677259713411331,0.97571212053299,0.218849316239357,-0.00952974893152714,0.977037847042084,0.201919630169868,0.0680119544267654,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,0.965206980705261,0.261487156152725,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.97571212053299,0.218849271535873,0.00952975638210773,0.997703969478607,0,-0.0677258223295212,0.972207069396973,0.183717668056488,-0.145124807953835,0.977037847042084,0.201919630169868,-0.0680118054151535,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,0.972207069396973,-0.18371769785881,0.145124822854996,0.997703969478607,0,0.0677258297801018,0.97571212053299,-0.218849286437035,-0.00952974613755941,0.977037847042084,-0.201919630169868,0.0680118054151535,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,-0.183717846870422,0.145124554634094,-0.972207069396973,0,0.0677257031202316,-0.997704029083252,-0.218849360942841,-0.0095297284424305,-0.97571212053299,-0.20191977918148,0.068011686205864,-0.977037727832794,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906,-0.26148721575737,-0,-0.965207040309906, +0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0.218849450349808,0.00952971167862415,-0.97571212053299,0,-0.0677258521318436,-0.997703969478607,-0.1837178170681,-0.145124852657318,-0.972207069396973,-0.201919764280319,-0.0680118426680565,-0.977037727832794,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0,0,-1,0,0,-1,0.183717772364616,0.145124807953835,-0.972207069396973,0,0.0677258297801018,-0.997703969478607,0.218849375844002,-0.00952972657978535,-0.97571212053299,0.201919689774513,0.0680118054151535,-0.977037727832794,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0.26148721575737,0,-0.965207040309906,0,0,-1,0,0,-1,0,-0,-1,0,0,-1,0.183717876672745,0.145124495029449,0.972207069396973,0,0.0677256807684898,0.997704029083252,0.218849375844002,-0.00952972192317247,0.97571212053299,0.20191977918148,0.0680116564035416,0.977037727832794,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0.26148721575737,-0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0.218849420547485,0.0095297135412693,0.97571212053299,0,-0.0677258297801018,0.997703969478607,0.183717846870422,-0.145124778151512,0.972207069396973,0.20191977918148,-0.0680118054151535,0.977037727832794,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,-0.183717921376228,0.145124837756157,0.972207009792328,0,0.0677258521318436,0.997703969478607,-0.21884948015213,-0.00952970236539841,0.97571212053299,-0.201919838786125,0.0680118277668953,0.977037727832794,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,-0.26148721575737,0,0.965207040309906,0,-0,1,0,-0,1,0,-0,1,0,-0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0, +1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,-0,1,-0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,-0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,0,0,1,0,0,1,0,0,1,0,0,1, +0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1 + } + TangentsW: *768 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "map1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *542 { + a: 0.375,0,0.625,0,0.375,0.25,0.625,0.25,0.375,0.5,0.625,0.5,0.375,0.75,0.625,0.75,0.375,1,0.625,1,0.875,0,0.875,0.25,0.125,0,0.125,0.25,0.5,0.125,0.5,0,0.5,1,0.625,0.125,0.5,0.25,0.375,0.125,0.5,0.375,0.625,0.375,0.75,0.25,0.5,0.5,0.375,0.375,0.25,0.25,0.5,0.625,0.625,0.625,0.875,0.125,0.5,0.75,0.375,0.625,0.125,0.125,0.5,0.875,0.625,0.875,0.75,0,0.5,1,0.375,0.875,0.25,0,0.75,0.125,0.75,0,0.875,0.125,0.75,0.25,0.25,0.125,0.25,0,0.25,0.25,0.125,0.125,0.4375,0.0625,0.375,0.0625,0.4375,0,0.4375,1,0.5,0.0625,0.4375,0.125,0.4375,0.3125,0.375,0.3125,0.3125,0.25,0.4375,0.25,0.5,0.3125,0.4375,0.375,0.4375,0.5625,0.375,0.5625,0.125,0.1875,0.4375,0.5,0.5,0.5625,0.4375,0.625,0.4375,0.8125,0.375,0.8125,0.1875,0,0.4375,0.75,0.5,0.8125,0.4375,0.875,0.6875,0.0625,0.625,0.0625,0.625,0.9375,0.6875,0,0.75,0.0625,0.6875,0.125,0.1875,0.0625,0.375,0.6875,0.125,0.0625,0.1875,0,0.25,0.0625,0.1875,0.125,0.5625,0.0625,0.5625,0,0.5625,1,0.5625,0.125,0.5625,0.1875,0.625,0.1875,0.5625,0.25,0.5,0.1875,0.4375,0.1875,0.375,0.1875,0.5625,0.3125,0.625,0.3125,0.6875,0.25,0.5625,0.375,0.5625,0.4375,0.625,0.4375,0.8125,0.25,0.5625,0.5,0.5,0.4375,0.4375,0.4375,0.375,0.4375,0.1875,0.25,0.5625,0.5625,0.625,0.5625,0.875,0.1875,0.5625,0.625,0.5625,0.6875,0.625,0.6875,0.875,0.0625,0.5625,0.75,0.5,0.6875,0.4375,0.6875,0.375,0.6875,0.5625,0.8125,0.625,0.8125,0.8125,0,0.5625,0.875,0.5625,0.9375,0.625,0.9375,0.5625,1,0.5,0.9375,0.4375,0.9375,0.4375,1,0.375,0.9375,0.3125,0,0.8125,0.0625,0.8125,0,0.875,0.0625,0.8125,0.125,0.8125,0.1875,0.875,0.1875,0.8125,0.25,0.75,0.1875,0.6875,0.1875,0.6875,0.25,0.3125,0.0625,0.3125,0,0.3125,0.125,0.3125,0.1875,0.3125,0.25,0.25,0.1875,0.1875,0.1875,0.1875,0.25,0.125,0.1875,0.4375,0.125,0.375,0.125,0.375,0.0625,0.4375,0.0625,0.4375,0.375,0.375,0.375,0.375,0.3125,0.4375,0.3125,0.4375,0.625,0.375,0.625,0.375,0.5625,0.4375,0.5625,0.4375,0.875,0.375,0.875,0.375,0.8125,0.4375,0.8125,0.6875,0.125,0.625,0.125,0.625,0.0625,0.6875,0.0625,0.1875,0.125,0.125,0.125,0.125,0.0625,0.1875,0.0625,0.5,0.0625,0.5,0,0.5625,0, +0.5625,0.0625,0.5625,0.125,0.625,0.1875,0.5625,0.1875,0.5,0.1875,0.5,0.25,0.4375,0.25,0.4375,0.1875,0.5,0.3125,0.5625,0.25,0.5625,0.3125,0.5625,0.375,0.625,0.375,0.625,0.4375,0.5625,0.4375,0.5,0.4375,0.5,0.5,0.4375,0.5,0.4375,0.4375,0.5,0.5625,0.5625,0.5,0.5625,0.5625,0.5625,0.625,0.625,0.625,0.625,0.6875,0.5625,0.6875,0.5,0.6875,0.5,0.75,0.4375,0.75,0.4375,0.6875,0.5,0.8125,0.5625,0.75,0.5625,0.8125,0.5625,0.875,0.625,0.875,0.625,0.9375,0.5625,0.9375,0.5,0.9375,0.5,1,0.4375,1,0.4375,0.9375,0.75,0.0625,0.75,0,0.8125,0,0.8125,0.0625,0.8125,0.125,0.875,0.125,0.875,0.1875,0.8125,0.1875,0.75,0.1875,0.75,0.25,0.6875,0.25,0.6875,0.1875,0.25,0.0625,0.25,0,0.3125,0,0.3125,0.0625,0.3125,0.125,0.375,0.1875,0.3125,0.1875,0.25,0.1875,0.25,0.25,0.1875,0.25,0.1875,0.1875,0.375,0,0.4375,0,0.5,0.125,0.375,0.25,0.5,0.375,0.375,0.5,0.5,0.625,0.375,0.75,0.5,0.875,0.625,0,0.6875,0,0.75,0.125,0.125,0,0.1875,0,0.25,0.125,0.625,0.25,0.625,0.3125,0.625,0.5,0.375,0.4375,0.625,0.5625,0.625,0.75,0.375,0.6875,0.625,0.8125,0.625,1,0.5625,1,0.375,1,0.375,0.9375,0.875,0,0.875,0.0625,0.875,0.25,0.8125,0.25,0.3125,0.25,0.125,0.25,0.125,0.1875 + } + UVIndex: *768 { + a: 51,19,47,46,57,24,53,52,63,30,59,58,69,36,65,64,75,17,71,70,81,45,78,76,50,15,83,82,85,17,87,86,89,18,55,90,56,18,88,92,95,21,97,96,100,23,61,101,62,23,99,104,107,27,109,108,112,29,67,113,68,29,111,115,118,33,120,119,122,35,124,123,74,39,128,127,130,40,132,131,134,41,136,135,80,43,138,137,139,19,91,140,142,44,144,143,47,0,48,46,48,15,50,46,50,14,51,46,53,2,55,52,55,18,56,52,56,20,57,52,59,4,61,58,61,23,62,58,62,26,63,58,65,6,67,64,67,29,68,64,68,32,69,64,71,1,73,70,73,39,74,70,74,38,75,70,78,12,79,76,79,43,80,76,80,42,81,76,83,1,71,82,71,17,85,82,85,14,50,82,87,3,88,86,88,18,89,86,89,14,85,86,55,2,91,90,91,19,51,90,51,14,89,90,88,3,93,92,93,21,95,92,95,20,56,92,97,5,99,96,99,23,100,96,100,20,95,96,61,4,102,101,102,24,57,101,57,20,100,101,99,5,105,104,105,27,107,104,107,26,62,104,109,7,111,108,111,29,112,108,112,26,107,108,67,6,114,113,114,30,63,113,63,26,112,113,111,7,116,115,116,33,118,115,118,32,68,115,120,9,121,119,121,35,122,119,122,32,118,119,124,8,125,123,125,36,69,123,69,32,122,123,128,10,129,127,129,40,130,127,130,38,74,127,132,11,133,131,133,41,134,131,134,38,130,131,136,3,87,135,87,17,75,135,75,38,134,135,138,0,47,137,47,19,139,137,139,42,80,137,91,2,141,140,141,44,142,140,142,42,139,140,144,13,145,143,145,45,81,143,81,42,142,143,146,149,148,147,150,153,152,151,154,157,156,155,158,161,160,159,162,165,164,163,166,169,168,167,170,173,172,171,174,176,175,163,177,180,179,178,181,183,182,178,184,187,186,185,188,191,190,189,192,194,193,189,195,198,197,196,199,202,201,200,203,205,204,200,206,209,208,207,210,213,212,211,214,217,216,215,218,221,220,219,222,225,224,223,226,229,228,227,230,232,231,147,233,236,235,234,148,149,238,237,238,149,170,171,170,149,146,239,152,153,179,240,179,153,181,178,181,153,150,241,156,157,190,242,190,157,192,189,192,157,154,243,160,161,201,244,201,161,203,200,203,161,158,245,164,165,247,246,247,165,214,215,214,165,162,248,168,169,250,249,250,169,226,227,226,169,166,251,172,173,164,246,164,173,174,163,174,173,170,239,175,176,182,252,182,176,177,178,177,176,174,239, +179,180,231,240,231,180,146,147,146,180,177,239,182,183,253,252,253,183,184,185,184,183,181,241,186,187,193,254,193,187,188,189,188,187,184,241,190,191,255,242,255,191,150,151,150,191,188,241,193,194,256,254,256,194,195,196,195,194,192,243,197,198,204,257,204,198,199,200,199,198,195,243,201,202,258,244,258,202,154,155,154,202,199,243,204,205,259,257,259,205,206,207,206,205,203,245,208,209,261,260,261,209,210,211,210,209,206,245,212,213,263,262,263,213,158,159,158,213,210,245,216,217,265,264,265,217,218,219,218,217,214,248,220,221,267,266,267,221,222,223,222,221,218,248,224,225,175,252,175,225,162,163,162,225,222,248,228,229,148,237,148,229,230,147,230,229,226,251,231,232,268,240,268,232,233,234,233,232,230,251,235,236,270,269,270,236,166,167,166,236,233,251 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *384 { + a: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + } + Model: 2359439406816, "Model::Cube2", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",-1.04023893373156,0.998288783259251,-1.04375962988677 + P: "Lcl Scaling", "Lcl Scaling", "", "A",10,10,10 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 2359439411456, "Model::Куб1", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",1.04023893373156,-0.998288783259251,1.04375962988677 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 2359439409136, "Model::Cube3", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",-1.0671176743957,0.998288783259251,9.39023469168045 + P: "Lcl Scaling", "Lcl Scaling", "", "A",10,10,10 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Model: 2359439416096, "Model::Куб1", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",1.04023893373156,-0.998288783259251,1.1806740271636 + P: "Lcl Scaling", "Lcl Scaling", "", "A",0.77384837213491,0.77384837213491,0.77384837213491 + P: "currentUVSet", "KString", "", "U", "map1" + } + Shading: T + Culling: "CullingOff" + } + Material: 2359823919504, "Material::Mat_Green", "" { + Version: 102 + ShadingModel: "lambert" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",0,1,0 + P: "DiffuseFactor", "Number", "", "A",0.800000011920929 + P: "TransparencyFactor", "Number", "", "A",1 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",0,0.800000011920929,0 + P: "Opacity", "double", "Number", "",1 + } + } + Material: 2359823921584, "Material::Mat_Red", "" { + Version: 102 + ShadingModel: "lambert" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",1,0,0 + P: "DiffuseFactor", "Number", "", "A",0.800000011920929 + P: "TransparencyFactor", "Number", "", "A",1 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",0.800000011920929,0,0 + P: "Opacity", "double", "Number", "",1 + } + } + AnimationStack: 2359349464816, "AnimStack::Take 001", "" { + Properties70: { + P: "LocalStart", "KTime", "Time", "",1924423250 + P: "LocalStop", "KTime", "Time", "",230930790000 + P: "ReferenceStart", "KTime", "Time", "",1924423250 + P: "ReferenceStop", "KTime", "Time", "",230930790000 + } + } + AnimationLayer: 2359327403664, "AnimLayer::BaseLayer", "" { + } +} + +; Object connections +;------------------------------------------------------------------ + +Connections: { + + ;Model::Cube2, Model::RootNode + C: "OO",2359439406816,0 + + ;Model::Cube3, Model::RootNode + C: "OO",2359439409136,0 + + ;AnimLayer::BaseLayer, AnimStack::Take 001 + C: "OO",2359327403664,2359349464816 + + ;Geometry::, Model::Cube2 + C: "OO",2358377979296,2359439406816 + + ;Material::Mat_Green, Model::Cube2 + C: "OO",2359823919504,2359439406816 + + ;Model::Куб1, Model::Cube2 + C: "OO",2359439411456,2359439406816 + + ;Geometry::, Model::Куб1 + C: "OO",2358377961872,2359439411456 + + ;Material::Mat_Green, Model::Куб1 + C: "OO",2359823919504,2359439411456 + + ;Geometry::, Model::Cube3 + C: "OO",2358377982464,2359439409136 + + ;Material::Mat_Red, Model::Cube3 + C: "OO",2359823921584,2359439409136 + + ;Model::Куб1, Model::Cube3 + C: "OO",2359439416096,2359439409136 + + ;Geometry::, Model::Куб1 + C: "OO",2358377979824,2359439416096 + + ;Material::Mat_Red, Model::Куб1 + C: "OO",2359823921584,2359439416096 +} +;Takes section +;---------------------------------------------------- + +Takes: { + Current: "Take 001" + Take: "Take 001" { + FileName: "Take_001.tak" + LocalTime: 1924423250,230930790000 + ReferenceTime: 1924423250,230930790000 + } +} diff --git a/test/models/FBX/embedded_ascii/box_embedded_texture_fragmented.fbx b/test/models/FBX/embedded_ascii/box_embedded_texture_fragmented.fbx new file mode 100644 index 000000000..6a476d3a1 --- /dev/null +++ b/test/models/FBX/embedded_ascii/box_embedded_texture_fragmented.fbx @@ -0,0 +1,697 @@ +; FBX 7.5.0 project file +; ---------------------------------------------------- + +FBXHeaderExtension: { + FBXHeaderVersion: 1003 + FBXVersion: 7500 + CreationTimeStamp: { + Version: 1000 + Year: 2019 + Month: 5 + Day: 14 + Hour: 12 + Minute: 35 + Second: 1 + Millisecond: 267 + } + Creator: "FBX SDK/FBX Plugins version 2018.1.1" + SceneInfo: "SceneInfo::GlobalInfo", "UserData" { + Type: "UserData" + Version: 100 + MetaData: { + Version: 100 + Title: "" + Subject: "" + Author: "" + Keywords: "" + Revision: "" + Comment: "" + } + Properties70: { + P: "DocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\box_embedded_texture_fragmented.fbx" + P: "SrcDocumentUrl", "KString", "Url", "", "U:\Some\Absolute\Path\box_embedded_texture_fragmented.fbx" + P: "Original", "Compound", "", "" + P: "Original|ApplicationVendor", "KString", "", "", "Autodesk" + P: "Original|ApplicationName", "KString", "", "", "Maya" + P: "Original|ApplicationVersion", "KString", "", "", "201800" + P: "Original|DateTime_GMT", "DateTime", "", "", "14/05/2019 11:35:01.267" + P: "Original|FileName", "KString", "", "", "U:\Some\Absolute\Path\box_embedded_texture_fragmented.fbx" + P: "LastSaved", "Compound", "", "" + P: "LastSaved|ApplicationVendor", "KString", "", "", "Autodesk" + P: "LastSaved|ApplicationName", "KString", "", "", "Maya" + P: "LastSaved|ApplicationVersion", "KString", "", "", "201800" + P: "LastSaved|DateTime_GMT", "DateTime", "", "", "14/05/2019 11:35:01.267" + P: "Original|ApplicationActiveProject", "KString", "", "", "U:\Some\Absolute\Path" + } + } +} +GlobalSettings: { + Version: 1000 + Properties70: { + P: "UpAxis", "int", "Integer", "",1 + P: "UpAxisSign", "int", "Integer", "",1 + P: "FrontAxis", "int", "Integer", "",2 + P: "FrontAxisSign", "int", "Integer", "",1 + P: "CoordAxis", "int", "Integer", "",0 + P: "CoordAxisSign", "int", "Integer", "",1 + P: "OriginalUpAxis", "int", "Integer", "",1 + P: "OriginalUpAxisSign", "int", "Integer", "",1 + P: "UnitScaleFactor", "double", "Number", "",100 + P: "OriginalUnitScaleFactor", "double", "Number", "",1 + P: "AmbientColor", "ColorRGB", "Color", "",0,0,0 + P: "DefaultCamera", "KString", "", "", "Producer Perspective" + P: "TimeMode", "enum", "", "",6 + P: "TimeProtocol", "enum", "", "",2 + P: "SnapOnFrameMode", "enum", "", "",0 + P: "TimeSpanStart", "KTime", "Time", "",0 + P: "TimeSpanStop", "KTime", "Time", "",153953860000 + P: "CustomFrameRate", "double", "Number", "",-1 + P: "TimeMarker", "Compound", "", "" + P: "CurrentTimeMarker", "int", "Integer", "",-1 + } +} + +; Documents Description +;------------------------------------------------------------------ + +Documents: { + Count: 1 + Document: 1827090966928, "", "Scene" { + Properties70: { + P: "SourceObject", "object", "", "" + P: "ActiveAnimStackName", "KString", "", "", "Take 001" + } + RootNode: 0 + } +} + +; Document References +;------------------------------------------------------------------ + +References: { +} + +; Object definitions +;------------------------------------------------------------------ + +Definitions: { + Version: 100 + Count: 17 + ObjectType: "GlobalSettings" { + Count: 1 + } + ObjectType: "AnimationStack" { + Count: 1 + PropertyTemplate: "FbxAnimStack" { + Properties70: { + P: "Description", "KString", "", "", "" + P: "LocalStart", "KTime", "Time", "",0 + P: "LocalStop", "KTime", "Time", "",0 + P: "ReferenceStart", "KTime", "Time", "",0 + P: "ReferenceStop", "KTime", "Time", "",0 + } + } + } + ObjectType: "AnimationLayer" { + Count: 1 + PropertyTemplate: "FbxAnimLayer" { + Properties70: { + P: "Weight", "Number", "", "A",100 + P: "Mute", "bool", "", "",0 + P: "Solo", "bool", "", "",0 + P: "Lock", "bool", "", "",0 + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BlendMode", "enum", "", "",0 + P: "RotationAccumulationMode", "enum", "", "",0 + P: "ScaleAccumulationMode", "enum", "", "",0 + P: "BlendModeBypass", "ULongLong", "", "",0 + } + } + } + ObjectType: "Geometry" { + Count: 1 + PropertyTemplate: "FbxMesh" { + Properties70: { + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "BBoxMin", "Vector3D", "Vector", "",0,0,0 + P: "BBoxMax", "Vector3D", "Vector", "",0,0,0 + P: "Primary Visibility", "bool", "", "",1 + P: "Casts Shadows", "bool", "", "",1 + P: "Receive Shadows", "bool", "", "",1 + } + } + } + ObjectType: "Material" { + Count: 1 + PropertyTemplate: "FbxSurfacePhong" { + Properties70: { + P: "ShadingModel", "KString", "", "", "Phong" + P: "MultiLayer", "bool", "", "",0 + P: "EmissiveColor", "Color", "", "A",0,0,0 + P: "EmissiveFactor", "Number", "", "A",1 + P: "AmbientColor", "Color", "", "A",0.2,0.2,0.2 + P: "AmbientFactor", "Number", "", "A",1 + P: "DiffuseColor", "Color", "", "A",0.8,0.8,0.8 + P: "DiffuseFactor", "Number", "", "A",1 + P: "Bump", "Vector3D", "Vector", "",0,0,0 + P: "NormalMap", "Vector3D", "Vector", "",0,0,0 + P: "BumpFactor", "double", "Number", "",1 + P: "TransparentColor", "Color", "", "A",0,0,0 + P: "TransparencyFactor", "Number", "", "A",0 + P: "DisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "DisplacementFactor", "double", "Number", "",1 + P: "VectorDisplacementColor", "ColorRGB", "Color", "",0,0,0 + P: "VectorDisplacementFactor", "double", "Number", "",1 + P: "SpecularColor", "Color", "", "A",0.2,0.2,0.2 + P: "SpecularFactor", "Number", "", "A",1 + P: "ShininessExponent", "Number", "", "A",20 + P: "ReflectionColor", "Color", "", "A",0,0,0 + P: "ReflectionFactor", "Number", "", "A",1 + } + } + } + ObjectType: "Texture" { + Count: 1 + PropertyTemplate: "FbxFileTexture" { + Properties70: { + P: "TextureTypeUse", "enum", "", "",0 + P: "Texture alpha", "Number", "", "A",1 + P: "CurrentMappingType", "enum", "", "",0 + P: "WrapModeU", "enum", "", "",0 + P: "WrapModeV", "enum", "", "",0 + P: "UVSwap", "bool", "", "",0 + P: "PremultiplyAlpha", "bool", "", "",1 + P: "Translation", "Vector", "", "A",0,0,0 + P: "Rotation", "Vector", "", "A",0,0,0 + P: "Scaling", "Vector", "", "A",1,1,1 + P: "TextureRotationPivot", "Vector3D", "Vector", "",0,0,0 + P: "TextureScalingPivot", "Vector3D", "Vector", "",0,0,0 + P: "CurrentTextureBlendMode", "enum", "", "",1 + P: "UVSet", "KString", "", "", "default" + P: "UseMaterial", "bool", "", "",0 + P: "UseMipMap", "bool", "", "",0 + } + } + } + ObjectType: "Model" { + Count: 1 + PropertyTemplate: "FbxNode" { + Properties70: { + P: "QuaternionInterpolate", "enum", "", "",0 + P: "RotationOffset", "Vector3D", "Vector", "",0,0,0 + P: "RotationPivot", "Vector3D", "Vector", "",0,0,0 + P: "ScalingOffset", "Vector3D", "Vector", "",0,0,0 + P: "ScalingPivot", "Vector3D", "Vector", "",0,0,0 + P: "TranslationActive", "bool", "", "",0 + P: "TranslationMin", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMax", "Vector3D", "Vector", "",0,0,0 + P: "TranslationMinX", "bool", "", "",0 + P: "TranslationMinY", "bool", "", "",0 + P: "TranslationMinZ", "bool", "", "",0 + P: "TranslationMaxX", "bool", "", "",0 + P: "TranslationMaxY", "bool", "", "",0 + P: "TranslationMaxZ", "bool", "", "",0 + P: "RotationOrder", "enum", "", "",0 + P: "RotationSpaceForLimitOnly", "bool", "", "",0 + P: "RotationStiffnessX", "double", "Number", "",0 + P: "RotationStiffnessY", "double", "Number", "",0 + P: "RotationStiffnessZ", "double", "Number", "",0 + P: "AxisLen", "double", "Number", "",10 + P: "PreRotation", "Vector3D", "Vector", "",0,0,0 + P: "PostRotation", "Vector3D", "Vector", "",0,0,0 + P: "RotationActive", "bool", "", "",0 + P: "RotationMin", "Vector3D", "Vector", "",0,0,0 + P: "RotationMax", "Vector3D", "Vector", "",0,0,0 + P: "RotationMinX", "bool", "", "",0 + P: "RotationMinY", "bool", "", "",0 + P: "RotationMinZ", "bool", "", "",0 + P: "RotationMaxX", "bool", "", "",0 + P: "RotationMaxY", "bool", "", "",0 + P: "RotationMaxZ", "bool", "", "",0 + P: "InheritType", "enum", "", "",0 + P: "ScalingActive", "bool", "", "",0 + P: "ScalingMin", "Vector3D", "Vector", "",0,0,0 + P: "ScalingMax", "Vector3D", "Vector", "",1,1,1 + P: "ScalingMinX", "bool", "", "",0 + P: "ScalingMinY", "bool", "", "",0 + P: "ScalingMinZ", "bool", "", "",0 + P: "ScalingMaxX", "bool", "", "",0 + P: "ScalingMaxY", "bool", "", "",0 + P: "ScalingMaxZ", "bool", "", "",0 + P: "GeometricTranslation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricRotation", "Vector3D", "Vector", "",0,0,0 + P: "GeometricScaling", "Vector3D", "Vector", "",1,1,1 + P: "MinDampRangeX", "double", "Number", "",0 + P: "MinDampRangeY", "double", "Number", "",0 + P: "MinDampRangeZ", "double", "Number", "",0 + P: "MaxDampRangeX", "double", "Number", "",0 + P: "MaxDampRangeY", "double", "Number", "",0 + P: "MaxDampRangeZ", "double", "Number", "",0 + P: "MinDampStrengthX", "double", "Number", "",0 + P: "MinDampStrengthY", "double", "Number", "",0 + P: "MinDampStrengthZ", "double", "Number", "",0 + P: "MaxDampStrengthX", "double", "Number", "",0 + P: "MaxDampStrengthY", "double", "Number", "",0 + P: "MaxDampStrengthZ", "double", "Number", "",0 + P: "PreferedAngleX", "double", "Number", "",0 + P: "PreferedAngleY", "double", "Number", "",0 + P: "PreferedAngleZ", "double", "Number", "",0 + P: "LookAtProperty", "object", "", "" + P: "UpVectorProperty", "object", "", "" + P: "Show", "bool", "", "",1 + P: "NegativePercentShapeSupport", "bool", "", "",1 + P: "DefaultAttributeIndex", "int", "Integer", "",-1 + P: "Freeze", "bool", "", "",0 + P: "LODBox", "bool", "", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",0,0,0 + P: "Lcl Rotation", "Lcl Rotation", "", "A",0,0,0 + P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1 + P: "Visibility", "Visibility", "", "A",1 + P: "Visibility Inheritance", "Visibility Inheritance", "", "",1 + } + } + } + ObjectType: "AnimationCurveNode" { + Count: 8 + PropertyTemplate: "FbxAnimCurveNode" { + Properties70: { + P: "d", "Compound", "", "" + } + } + } + ObjectType: "CollectionExclusive" { + Count: 1 + PropertyTemplate: "FbxDisplayLayer" { + Properties70: { + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "Show", "bool", "", "",1 + P: "Freeze", "bool", "", "",0 + P: "LODBox", "bool", "", "",0 + } + } + } + ObjectType: "Video" { + Count: 1 + PropertyTemplate: "FbxVideo" { + Properties70: { + P: "Path", "KString", "XRefUrl", "", "" + P: "RelPath", "KString", "XRefUrl", "", "" + P: "Color", "ColorRGB", "Color", "",0.8,0.8,0.8 + P: "ClipIn", "KTime", "Time", "",0 + P: "ClipOut", "KTime", "Time", "",0 + P: "Offset", "KTime", "Time", "",0 + P: "PlaySpeed", "double", "Number", "",0 + P: "FreeRunning", "bool", "", "",0 + P: "Loop", "bool", "", "",0 + P: "Mute", "bool", "", "",0 + P: "AccessMode", "enum", "", "",0 + P: "ImageSequence", "bool", "", "",0 + P: "ImageSequenceOffset", "int", "Integer", "",0 + P: "FrameRate", "double", "Number", "",0 + P: "LastFrame", "int", "Integer", "",0 + P: "Width", "int", "Integer", "",0 + P: "Height", "int", "Integer", "",0 + P: "StartFrame", "int", "Integer", "",0 + P: "StopFrame", "int", "Integer", "",0 + P: "InterlaceMode", "enum", "", "",0 + } + } + } +} + +; Object properties +;------------------------------------------------------------------ + +Objects: { + Geometry: 1827080161440, "Geometry::", "Mesh" { + Vertices: *24 { + a: -0.5,-0.5,-0.5,0.5,-0.50000011920929,-0.5,-0.5,0.50000011920929,-0.5,0.5,0.50000011920929,-0.5,-0.5,-0.500000059604645,0.5,0.5,-0.500000059604645,0.5,-0.5,0.500000059604645,0.5,0.5,0.500000059604645,0.5 + } + PolygonVertexIndex: *24 { + a: 0,2,3,-2,4,5,7,-7,0,1,5,-5,1,3,7,-6,3,2,6,-8,2,0,4,-7 + } + Edges: *12 { + a: 0,1,2,3,4,5,6,7,9,11,13,17 + } + GeometryVersion: 124 + LayerElementNormal: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Normals: *72 { + a: 0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,-5.96046447753906e-08,-1,0,-5.96046447753906e-08,-1,0,-5.96046447753906e-08,-1,0,-5.96046447753906e-08,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,5.96046447753906e-08,0,1,5.96046447753906e-08,0,1,5.96046447753906e-08,0,1,5.96046447753906e-08,-1,0,0,-1,0,0,-1,0,0,-1,0,0 + } + NormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementBinormal: 0 { + Version: 102 + Name: "UVChannel_1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: 1.19209289550781e-07,1,0,5.96046447753906e-08,1,0,0,1,0,5.96046447753906e-08,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,0,1,0,0,1,0,0,1,0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,0,1,-0,-5.96046447753906e-08,1,-0,-5.96046447753906e-08,1,-0,-5.96046447753906e-08,1,-0,-5.96046447753906e-08,1,0,0,1,0,0,1,0,0,1,0,0,1 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementBinormal: 1 { + Version: 102 + Name: "UVChannel_3" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Binormals: *72 { + a: -1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-0,0,-1,-0,0,-1,0,-0,-1,-0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,5.96046447753906e-08,-1,0,5.96046447753906e-08,-1,0,5.96046447753906e-08,-1,0,5.96046447753906e-08,-1,-0,0,-1,-0,0,-1,-0,0,-1,-0,0,-1 + } + BinormalsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + + } + LayerElementTangent: 0 { + Version: 102 + Name: "UVChannel_1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: -1,1.19209289550781e-07,0,-1,5.96046447753906e-08,0,-1,-0,0,-1,5.96046447753906e-08,0,1,-0,-0,1,-0,0,1,-0,0,1,-0,0,1,-5.96046447753906e-08,-0,1,-5.96046447753906e-08,0,1,-5.96046447753906e-08,0,1,-5.96046447753906e-08,0,-0,1,-0,0,1,-0,0,1,-0,0,1,-0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,-0,0,-1,-0,0,-1,0,0,-1,0,0,-1,0 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementTangent: 1 { + Version: 102 + Name: "UVChannel_3" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "Direct" + Tangents: *72 { + a: -0,-1,0,-0,-1,0,-0,-1,0,-0,-1,0,0,1,0,0,1,0,-0,1,-0,0,1,0,-1,5.96046447753906e-08,0,-1,5.96046447753906e-08,0,-1,5.96046447753906e-08,-0,-1,5.96046447753906e-08,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,1,-0,-0,1,-0,-0,1,-0,-0,1,-0,-0,0,1,-0,0,1,-0,0,1,-0,0,1,-0 + } + TangentsW: *24 { + a: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + } + } + LayerElementUV: 0 { + Version: 101 + Name: "UVChannel_1" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *48 { + a: 1,0,0,0,1,1,0,1,0,0,1,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,1,0,0,1,1,1 + } + UVIndex: *24 { + a: 0,2,3,1,4,5,7,6,8,9,11,10,12,13,15,14,16,17,19,18,20,21,23,22 + } + } + LayerElementUV: 1 { + Version: 101 + Name: "UVChannel_3" + MappingInformationType: "ByPolygonVertex" + ReferenceInformationType: "IndexToDirect" + UV: *48 { + a: 0.28125,0.28125,0,0.28125,0,0,0.28125,0,0.34375,1,0.34375,0.71875,0.625,0.71875,0.625,1,0.28125,0.65625,0,0.65625,0,0.375,0.28125,0.375,0.625,0.28125,0.34375,0.28125,0.34375,0,0.625,0,0.28125,1,0,1,0,0.71875,0.28125,0.71875,0.625,0.65625,0.34375,0.65625,0.34375,0.375,0.625,0.375 + } + UVIndex: *24 { + a: 0,1,2,3,4,5,6,7,20,21,22,23,8,9,10,11,16,17,18,19,12,13,14,15 + } + } + LayerElementSmoothing: 0 { + Version: 102 + Name: "" + MappingInformationType: "ByEdge" + ReferenceInformationType: "Direct" + Smoothing: *12 { + a: 0,0,0,0,0,0,0,0,0,0,0,0 + } + } + LayerElementMaterial: 0 { + Version: 101 + Name: "" + MappingInformationType: "AllSame" + ReferenceInformationType: "IndexToDirect" + Materials: *1 { + a: 0 + } + } + Layer: 0 { + Version: 100 + LayerElement: { + Type: "LayerElementNormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementMaterial" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementSmoothing" + TypedIndex: 0 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 0 + } + } + Layer: 1 { + Version: 100 + LayerElement: { + Type: "LayerElementBinormal" + TypedIndex: 1 + } + LayerElement: { + Type: "LayerElementTangent" + TypedIndex: 1 + } + LayerElement: { + Type: "LayerElementUV" + TypedIndex: 1 + } + } + } + Model: 1826985145024, "Model::Box", "Mesh" { + Version: 232 + Properties70: { + P: "RotationActive", "bool", "", "",1 + P: "InheritType", "enum", "", "",1 + P: "ScalingMax", "Vector3D", "Vector", "",0,0,0 + P: "DefaultAttributeIndex", "int", "Integer", "",0 + P: "Lcl Translation", "Lcl Translation", "", "A",0,0.5,2.18556946492754e-06 + P: "Lcl Rotation", "Lcl Rotation", "", "A",-90,0,0 + P: "currentUVSet", "KString", "", "U", "UVChannel_1" + P: "mr displacement use global settings", "Bool", "", "A+U",1 + P: "mr displacement view dependent", "Bool", "", "A+U",1 + P: "mr displacement method", "Integer", "", "A+U",6,6,6 + P: "mr displacement smoothing on", "Bool", "", "A+U",1 + P: "mr displacement edge length", "Number", "", "A+U",2,2,2 + P: "mr displacement max displace", "Number", "", "A+U",20,20,20 + P: "mr displacement parametric subdivision level", "Integer", "", "A+U",5,5,5 + P: "MaxHandle", "Integer", "", "A+UH",1,0,0 + } + Shading: T + Culling: "CullingOff" + } + Material: 1826343864784, "Material::Default", "" { + Version: 102 + ShadingModel: "phong" + MultiLayer: 0 + Properties70: { + P: "AmbientColor", "Color", "", "A",0,0,0 + P: "DiffuseColor", "Color", "", "A",1,1,1 + P: "TransparencyFactor", "Number", "", "A",1 + P: "SpecularColor", "Color", "", "A",0,0,0 + P: "ShininessExponent", "Number", "", "A",2 + P: "Emissive", "Vector3D", "Vector", "",0,0,0 + P: "Ambient", "Vector3D", "Vector", "",0,0,0 + P: "Diffuse", "Vector3D", "Vector", "",1,1,1 + P: "Specular", "Vector3D", "Vector", "",0,0,0 + P: "Shininess", "double", "Number", "",2 + P: "Opacity", "double", "Number", "",1 + P: "Reflectivity", "double", "Number", "",0 + } + } + Video: 1826343863824, "Video::Map #2", "Clip" { + Type: "Clip" + Properties70: { + P: "Path", "KString", "XRefUrl", "", "U:/Some/Absolute/Path/paper.png" + P: "RelPath", "KString", "XRefUrl", "", "paper.png" + } + UseMipMap: 0 + Filename: "U:/Some/Absolute/Path/paper.png" + RelativeFilename: "paper.png" + Content: , + "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", + "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" + } + Texture: 1826343863344, "Texture::Map #2", "" { + Type: "TextureVideoClip" + Version: 202 + TextureName: "Texture::Map #2" + Properties70: { + P: "CurrentTextureBlendMode", "enum", "", "",0 + P: "UVSet", "KString", "", "", "UVChannel_1" + P: "UseMaterial", "bool", "", "",1 + } + Media: "Video::Map #2" + FileName: "U:/Some/Absolute/Path/paper.png" + RelativeFilename: "paper.png" + ModelUVTranslation: 0,0 + ModelUVScaling: 1,1 + Texture_Alpha_Source: "None" + Cropping: 0,0,0,0 + } + AnimationStack: 1827077611568, "AnimStack::Take 001", "" { + Properties70: { + P: "LocalStop", "KTime", "Time", "",153953860000 + P: "ReferenceStop", "KTime", "Time", "",153953860000 + } + } + AnimationCurveNode: 1827077610320, "AnimCurveNode::mr displacement use global settings", "" { + Properties70: { + P: "d|mr displacement use global settings", "Bool", "", "A",1 + } + } + AnimationCurveNode: 1827077600128, "AnimCurveNode::mr displacement view dependent", "" { + Properties70: { + P: "d|mr displacement view dependent", "Bool", "", "A",1 + } + } + AnimationCurveNode: 1827077602624, "AnimCurveNode::mr displacement method", "" { + Properties70: { + P: "d|mr displacement method", "Integer", "", "A",6 + } + } + AnimationCurveNode: 1827077604912, "AnimCurveNode::mr displacement smoothing on", "" { + Properties70: { + P: "d|mr displacement smoothing on", "Bool", "", "A",1 + } + } + AnimationCurveNode: 1827077603664, "AnimCurveNode::mr displacement edge length", "" { + Properties70: { + P: "d|mr displacement edge length", "Number", "", "A",2 + } + } + AnimationCurveNode: 1827077606160, "AnimCurveNode::mr displacement max displace", "" { + Properties70: { + P: "d|mr displacement max displace", "Number", "", "A",20 + } + } + AnimationCurveNode: 1827077607824, "AnimCurveNode::mr displacement parametric subdivision level", "" { + Properties70: { + P: "d|mr displacement parametric subdivision level", "Integer", "", "A",5 + } + } + AnimationCurveNode: 1827077611360, "AnimCurveNode::MaxHandle", "" { + Properties70: { + P: "d|MaxHandle", "Integer", "", "A",1 + } + } + AnimationLayer: 1827070138064, "AnimLayer::BaseLayer", "" { + } + CollectionExclusive: 1827093511360, "DisplayLayer::Box", "DisplayLayer" { + Properties70: { + P: "Color", "ColorRGB", "Color", "",0.607999980449677,0,0.157000005245209 + } + } +} + +; Object connections +;------------------------------------------------------------------ + +Connections: { + + ;Model::Box, Model::RootNode + C: "OO",1826985145024,0 + + ;AnimLayer::BaseLayer, AnimStack::Take 001 + C: "OO",1827070138064,1827077611568 + + ;AnimCurveNode::mr displacement use global settings, AnimLayer::BaseLayer + C: "OO",1827077610320,1827070138064 + + ;AnimCurveNode::mr displacement view dependent, AnimLayer::BaseLayer + C: "OO",1827077600128,1827070138064 + + ;AnimCurveNode::mr displacement method, AnimLayer::BaseLayer + C: "OO",1827077602624,1827070138064 + + ;AnimCurveNode::mr displacement smoothing on, AnimLayer::BaseLayer + C: "OO",1827077604912,1827070138064 + + ;AnimCurveNode::mr displacement edge length, AnimLayer::BaseLayer + C: "OO",1827077603664,1827070138064 + + ;AnimCurveNode::mr displacement max displace, AnimLayer::BaseLayer + C: "OO",1827077606160,1827070138064 + + ;AnimCurveNode::mr displacement parametric subdivision level, AnimLayer::BaseLayer + C: "OO",1827077607824,1827070138064 + + ;AnimCurveNode::MaxHandle, AnimLayer::BaseLayer + C: "OO",1827077611360,1827070138064 + + ;Texture::Map #2, Material::Default + C: "OP",1826343863344,1826343864784, "DiffuseColor" + + ;Texture::Map #2, Material::Default + C: "OP",1826343863344,1826343864784, "TransparentColor" + + ;Video::Map #2, Texture::Map #2 + C: "OO",1826343863824,1826343863344 + + ;Geometry::, Model::Box + C: "OO",1827080161440,1826985145024 + + ;Material::Default, Model::Box + C: "OO",1826343864784,1826985145024 + + ;AnimCurveNode::mr displacement use global settings, Model::Box + C: "OP",1827077610320,1826985145024, "mr displacement use global settings" + + ;AnimCurveNode::mr displacement view dependent, Model::Box + C: "OP",1827077600128,1826985145024, "mr displacement view dependent" + + ;AnimCurveNode::mr displacement method, Model::Box + C: "OP",1827077602624,1826985145024, "mr displacement method" + + ;AnimCurveNode::mr displacement smoothing on, Model::Box + C: "OP",1827077604912,1826985145024, "mr displacement smoothing on" + + ;AnimCurveNode::mr displacement edge length, Model::Box + C: "OP",1827077603664,1826985145024, "mr displacement edge length" + + ;AnimCurveNode::mr displacement max displace, Model::Box + C: "OP",1827077606160,1826985145024, "mr displacement max displace" + + ;AnimCurveNode::mr displacement parametric subdivision level, Model::Box + C: "OP",1827077607824,1826985145024, "mr displacement parametric subdivision level" + + ;AnimCurveNode::MaxHandle, Model::Box + C: "OP",1827077611360,1826985145024, "MaxHandle" + + ;Model::Box, DisplayLayer::Box + C: "OO",1826985145024,1827093511360 +} +;Takes section +;---------------------------------------------------- + +Takes: { + Current: "Take 001" + Take: "Take 001" { + FileName: "Take_001.tak" + LocalTime: 0,153953860000 + ReferenceTime: 0,153953860000 + } +} diff --git a/test/models/PLY/cube_test.ply b/test/models/PLY/cube_test.ply index b460215dc..45fae27fb 100644 --- a/test/models/PLY/cube_test.ply +++ b/test/models/PLY/cube_test.ply @@ -1,6 +1,10 @@ ply format ascii 1.0 +<<<<<<< HEAD comment Created by Open Asset Import Library - http://assimp.sf.net (v4.1.732158294) +======= +comment Created by Open Asset Import Library - http://assimp.sf.net (v4.1.649942190) +>>>>>>> master element vertex 8 property float x property float y diff --git a/test/unit/utBatchLoader.cpp b/test/unit/utBatchLoader.cpp index d38f83b35..36dcbf288 100644 --- a/test/unit/utBatchLoader.cpp +++ b/test/unit/utBatchLoader.cpp @@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ #include "UnitTestPCH.h" -#include "Importer.h" +#include "Common/Importer.h" #include "TestIOSystem.h" using namespace ::Assimp; diff --git a/test/unit/utBlendImportMaterials.cpp b/test/unit/utBlendImportMaterials.cpp index cefacbe27..151c614c0 100644 --- a/test/unit/utBlendImportMaterials.cpp +++ b/test/unit/utBlendImportMaterials.cpp @@ -133,10 +133,10 @@ TEST_F(BlendImportMaterials, testImportMaterialwith2texturesAnd2TexCoordMappings // material has 2 diffuse textures ASSERT_TRUE(pTest->HasMaterials()); - EXPECT_EQ(1, pTest->mNumMaterials); + EXPECT_EQ(1u, pTest->mNumMaterials); const aiMaterial *pMat = pTest->mMaterials[0]; ASSERT_TRUE(nullptr != pMat); - ASSERT_EQ(2, pMat->GetTextureCount(aiTextureType_DIFFUSE)); + ASSERT_EQ(2u, pMat->GetTextureCount(aiTextureType_DIFFUSE)); aiString aPath; aiTextureMapping tm = aiTextureMapping::aiTextureMapping_OTHER; aiReturn result = pMat->GetTexture(aiTextureType_DIFFUSE, 0, &aPath, &tm); @@ -146,7 +146,7 @@ TEST_F(BlendImportMaterials, testImportMaterialwith2texturesAnd2TexCoordMappings // mesh has 2 texturecoord sets ASSERT_TRUE(pTest->HasMeshes()); - EXPECT_EQ(1, pTest->mNumMeshes); + EXPECT_EQ(1u, pTest->mNumMeshes); const aiMesh *pMesh = pTest->mMeshes[0]; ASSERT_TRUE(nullptr != pMesh); ASSERT_TRUE(pMesh->HasTextureCoords(0)); diff --git a/test/unit/utBlenderIntermediate.cpp b/test/unit/utBlenderIntermediate.cpp index c1b53bbfd..30f29017d 100644 --- a/test/unit/utBlenderIntermediate.cpp +++ b/test/unit/utBlenderIntermediate.cpp @@ -41,11 +41,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ #include "UnitTestPCH.h" -#include "BlenderIntermediate.h" -#include "./../include/assimp/camera.h" -#include "./../include/assimp/light.h" -#include "./../include/assimp/mesh.h" -#include "./../include/assimp/texture.h" +#include "Blender/BlenderIntermediate.h" +#include +#include +#include +#include using namespace ::Assimp; using namespace ::Assimp::Blender; diff --git a/test/unit/utD3MFImportExport.cpp b/test/unit/utD3MFImportExport.cpp index 9d97f0f19..c9b17d898 100644 --- a/test/unit/utD3MFImportExport.cpp +++ b/test/unit/utD3MFImportExport.cpp @@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include "D3MFExporter.h" +#include "3MF/D3MFExporter.h" class utD3MFImporterExporter : public AbstractImportExportBase { public: diff --git a/test/unit/utFBXImporterExporter.cpp b/test/unit/utFBXImporterExporter.cpp index f0de0c741..3180d96a2 100644 --- a/test/unit/utFBXImporterExporter.cpp +++ b/test/unit/utFBXImporterExporter.cpp @@ -76,6 +76,119 @@ TEST_F( utFBXImporterExporter, importBareBoxWithoutColorsAndTextureCoords ) { EXPECT_EQ(mesh->mNumVertices, 36); } +TEST_F(utFBXImporterExporter, importCubesWithNoNames) { + Assimp::Importer importer; + const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/cubes_nonames.fbx", aiProcess_ValidateDataStructure); + ASSERT_TRUE(scene); + + ASSERT_TRUE(scene->mRootNode); + const auto root = scene->mRootNode; + ASSERT_STREQ(root->mName.C_Str(), "RootNode"); + ASSERT_TRUE(root->mChildren); + ASSERT_EQ(root->mNumChildren, 2); + + const auto child0 = root->mChildren[0]; + ASSERT_TRUE(child0); + ASSERT_STREQ(child0->mName.C_Str(), "RootNode001"); + ASSERT_TRUE(child0->mChildren); + ASSERT_EQ(child0->mNumChildren, 1); + + const auto child00 = child0->mChildren[0]; + ASSERT_TRUE(child00); + ASSERT_STREQ(child00->mName.C_Str(), "RootNode001001"); + + const auto child1 = root->mChildren[1]; + ASSERT_TRUE(child1); + ASSERT_STREQ(child1->mName.C_Str(), "RootNode002"); + ASSERT_TRUE(child1->mChildren); + ASSERT_EQ(child1->mNumChildren, 1); + + const auto child10 = child1->mChildren[0]; + ASSERT_TRUE(child10); + ASSERT_STREQ(child10->mName.C_Str(), "RootNode002001"); +} + +TEST_F(utFBXImporterExporter, importCubesWithUnicodeDuplicatedNames) { + Assimp::Importer importer; + const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/cubes_with_names.fbx", aiProcess_ValidateDataStructure); + ASSERT_TRUE(scene); + + ASSERT_TRUE(scene->mRootNode); + const auto root = scene->mRootNode; + ASSERT_STREQ(root->mName.C_Str(), "RootNode"); + ASSERT_TRUE(root->mChildren); + ASSERT_EQ(root->mNumChildren, 2); + + const auto child0 = root->mChildren[0]; + ASSERT_TRUE(child0); + ASSERT_STREQ(child0->mName.C_Str(), "Cube2"); + ASSERT_TRUE(child0->mChildren); + ASSERT_EQ(child0->mNumChildren, 1); + + const auto child00 = child0->mChildren[0]; + ASSERT_TRUE(child00); + ASSERT_STREQ(child00->mName.C_Str(), "\xd0\x9a\xd1\x83\xd0\xb1\x31"); + + const auto child1 = root->mChildren[1]; + ASSERT_TRUE(child1); + ASSERT_STREQ(child1->mName.C_Str(), "Cube3"); + ASSERT_TRUE(child1->mChildren); + ASSERT_EQ(child1->mNumChildren, 1); + + const auto child10 = child1->mChildren[0]; + ASSERT_TRUE(child10); + ASSERT_STREQ(child10->mName.C_Str(), "\xd0\x9a\xd1\x83\xd0\xb1\x31""001"); +} + +TEST_F(utFBXImporterExporter, importCubesComplexTransform) { + Assimp::Importer importer; + const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/cubes_with_mirroring_and_pivot.fbx", aiProcess_ValidateDataStructure); + ASSERT_TRUE(scene); + + ASSERT_TRUE(scene->mRootNode); + const auto root = scene->mRootNode; + ASSERT_STREQ(root->mName.C_Str(), "RootNode"); + ASSERT_TRUE(root->mChildren); + ASSERT_EQ(root->mNumChildren, 2); + + const auto child0 = root->mChildren[0]; + ASSERT_TRUE(child0); + ASSERT_STREQ(child0->mName.C_Str(), "Cube2"); + ASSERT_TRUE(child0->mChildren); + ASSERT_EQ(child0->mNumChildren, 1); + + const auto child00 = child0->mChildren[0]; + ASSERT_TRUE(child00); + ASSERT_STREQ(child00->mName.C_Str(), "Cube1"); + + const auto child1 = root->mChildren[1]; + ASSERT_TRUE(child1); + ASSERT_STREQ(child1->mName.C_Str(), "Cube3"); + + auto parent = child1; + const size_t chain_length = 8u; + const char* chainStr[chain_length] = { + "Cube1001_$AssimpFbx$_Translation", + "Cube1001_$AssimpFbx$_RotationPivot", + "Cube1001_$AssimpFbx$_RotationPivotInverse", + "Cube1001_$AssimpFbx$_ScalingOffset", + "Cube1001_$AssimpFbx$_ScalingPivot", + "Cube1001_$AssimpFbx$_Scaling", + "Cube1001_$AssimpFbx$_ScalingPivotInverse", + "Cube1001" + }; + for (size_t i = 0; i < chain_length; ++i) + { + ASSERT_TRUE(parent->mChildren); + ASSERT_EQ(parent->mNumChildren, 1); + auto node = parent->mChildren[0]; + ASSERT_TRUE(node); + ASSERT_STREQ(node->mName.C_Str(), chainStr[i]); + parent = node; + } + ASSERT_EQ(0, parent->mNumChildren) << "Leaf node"; +} + TEST_F( utFBXImporterExporter, importPhongMaterial ) { Assimp::Importer importer; const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/FBX/phong_cube.fbx", aiProcess_ValidateDataStructure ); @@ -128,4 +241,29 @@ TEST_F(utFBXImporterExporter, importEmbeddedAsciiTest) { aiString path; aiTextureMapMode modes[2]; EXPECT_EQ(aiReturn_SUCCESS, mat->GetTexture(aiTextureType_DIFFUSE, 0, &path, nullptr, nullptr, nullptr, nullptr, modes)); + ASSERT_STREQ(path.C_Str(), "..\\..\\..\\Desktop\\uv_test.png"); + + ASSERT_EQ(1, scene->mNumTextures); + ASSERT_TRUE(scene->mTextures[0]->pcData); + ASSERT_EQ(439176u, scene->mTextures[0]->mWidth) << "FBX ASCII base64 compression splits data by 512Kb, it should be two parts for this texture"; +} + +TEST_F(utFBXImporterExporter, importEmbeddedFragmentedAsciiTest) { + // see https://github.com/assimp/assimp/issues/1957 + Assimp::Importer importer; + const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/FBX/embedded_ascii/box_embedded_texture_fragmented.fbx", aiProcess_ValidateDataStructure); + EXPECT_NE(nullptr, scene); + + EXPECT_EQ(1, scene->mNumMaterials); + aiMaterial *mat = scene->mMaterials[0]; + ASSERT_NE(nullptr, mat); + + aiString path; + aiTextureMapMode modes[2]; + ASSERT_EQ(aiReturn_SUCCESS, mat->GetTexture(aiTextureType_DIFFUSE, 0, &path, nullptr, nullptr, nullptr, nullptr, modes)); + ASSERT_STREQ(path.C_Str(), "paper.png"); + + ASSERT_EQ(1, scene->mNumTextures); + ASSERT_TRUE(scene->mTextures[0]->pcData); + ASSERT_EQ(968029u, scene->mTextures[0]->mWidth) << "FBX ASCII base64 compression splits data by 512Kb, it should be two parts for this texture"; } diff --git a/test/unit/utFindDegenerates.cpp b/test/unit/utFindDegenerates.cpp index d6ef803fa..ea539df27 100644 --- a/test/unit/utFindDegenerates.cpp +++ b/test/unit/utFindDegenerates.cpp @@ -42,8 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "UnitTestPCH.h" -#include - +#include "PostProcessing/FindDegenerates.h" using namespace std; using namespace Assimp; diff --git a/test/unit/utFindInvalidData.cpp b/test/unit/utFindInvalidData.cpp index 953c6728c..5b874a2a4 100644 --- a/test/unit/utFindInvalidData.cpp +++ b/test/unit/utFindInvalidData.cpp @@ -42,9 +42,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "UnitTestPCH.h" -#include -#include "../../include/assimp/mesh.h" - +#include "PostProcessing/FindInvalidDataProcess.h" +#include using namespace std; using namespace Assimp; @@ -61,8 +60,7 @@ protected: }; // ------------------------------------------------------------------------------------------------ -void FindInvalidDataProcessTest::SetUp() -{ +void FindInvalidDataProcessTest::SetUp() { ASSERT_TRUE( AI_MAX_NUMBER_OF_TEXTURECOORDS >= 3); piProcess = new FindInvalidDataProcess(); diff --git a/test/unit/utGenBoundingBoxesProcess.cpp b/test/unit/utGenBoundingBoxesProcess.cpp new file mode 100644 index 000000000..a26edb7e3 --- /dev/null +++ b/test/unit/utGenBoundingBoxesProcess.cpp @@ -0,0 +1,88 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2019, assimp team + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the following +conditions are met: + +* Redistributions of source code must retain the above +copyright notice, this list of conditions and the +following disclaimer. + +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other +materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its +contributors may be used to endorse or promote products +derived from this software without specific prior +written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------- +*/ +#include "UnitTestPCH.h" + +#include "PostProcessing/GenBoundingBoxesProcess.h" +#include +#include + +using namespace Assimp; + +class utGenBoundingBoxesProcess : public ::testing::Test { +public: + void SetUp() override { + mProcess = new GenBoundingBoxesProcess; + mMesh = new aiMesh(); + mMesh->mNumVertices = 100; + mMesh->mVertices = new aiVector3D[100]; + for (unsigned int i = 0; i < 100; ++i) { + mMesh->mVertices[i] = aiVector3D(i, i, i); + } + mScene = new aiScene(); + mScene->mNumMeshes = 1; + mScene->mMeshes = new aiMesh*[1]; + mScene->mMeshes[0] = mMesh; + } + + void TearDown() override { + delete mProcess; + delete mScene; + } + +protected: + GenBoundingBoxesProcess *mProcess; + aiMesh *mMesh; + aiScene* mScene; +}; + +TEST_F(utGenBoundingBoxesProcess, executeTest) { + mProcess->Execute(mScene); + + aiMesh* mesh = mScene->mMeshes[0]; + EXPECT_NE(nullptr, mesh); + EXPECT_EQ(0, mesh->mAABB.mMin.x); + EXPECT_EQ(0, mesh->mAABB.mMin.y); + EXPECT_EQ(0, mesh->mAABB.mMin.z); + + EXPECT_EQ(99, mesh->mAABB.mMax.x); + EXPECT_EQ(99, mesh->mAABB.mMax.y); + EXPECT_EQ(99, mesh->mAABB.mMax.z); +} diff --git a/test/unit/utGenNormals.cpp b/test/unit/utGenNormals.cpp index 65ab7c833..36f0b18bc 100644 --- a/test/unit/utGenNormals.cpp +++ b/test/unit/utGenNormals.cpp @@ -41,7 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ #include "UnitTestPCH.h" -#include + +#include "PostProcessing/GenVertexNormalsProcess.h" using namespace ::std; using namespace ::Assimp; diff --git a/test/unit/utJoinVertices.cpp b/test/unit/utJoinVertices.cpp index 067c0558c..6b832b73d 100644 --- a/test/unit/utJoinVertices.cpp +++ b/test/unit/utJoinVertices.cpp @@ -43,14 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include +#include "PostProcessing/JoinVerticesProcess.h" using namespace std; using namespace Assimp; -class JoinVerticesTest : public ::testing::Test -{ +class JoinVerticesTest : public ::testing::Test { public: virtual void SetUp(); virtual void TearDown(); diff --git a/test/unit/utLimitBoneWeights.cpp b/test/unit/utLimitBoneWeights.cpp index 48da66df0..5172976b4 100644 --- a/test/unit/utLimitBoneWeights.cpp +++ b/test/unit/utLimitBoneWeights.cpp @@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include +#include "PostProcessing/LimitBoneWeightsProcess.h" using namespace std; using namespace Assimp; diff --git a/test/unit/utMaterialSystem.cpp b/test/unit/utMaterialSystem.cpp index c2a9b520b..701b933e7 100644 --- a/test/unit/utMaterialSystem.cpp +++ b/test/unit/utMaterialSystem.cpp @@ -43,13 +43,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include +#include "Material/MaterialSystem.h" using namespace ::std; using namespace ::Assimp; -class MaterialSystemTest : public ::testing::Test -{ +class MaterialSystemTest : public ::testing::Test { public: virtual void SetUp() { this->pcMat = new aiMaterial(); } virtual void TearDown() { delete this->pcMat; } diff --git a/test/unit/utObjTools.cpp b/test/unit/utObjTools.cpp index e08b5de79..2de45d962 100644 --- a/test/unit/utObjTools.cpp +++ b/test/unit/utObjTools.cpp @@ -41,8 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ #include "UnitTestPCH.h" -#include "ObjTools.h" -#include "ObjFileParser.h" +#include "Obj/ObjTools.h" +#include "Obj/ObjFileParser.h" using namespace ::Assimp; diff --git a/test/unit/utPMXImporter.cpp b/test/unit/utPMXImporter.cpp index 3a1ce1f6a..62d3b0707 100644 --- a/test/unit/utPMXImporter.cpp +++ b/test/unit/utPMXImporter.cpp @@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include "SceneDiffer.h" #include "AbstractImportExportBase.h" -#include "MMDImporter.h" +#include "MMD/MMDImporter.h" #include diff --git a/test/unit/utPretransformVertices.cpp b/test/unit/utPretransformVertices.cpp index 0bf6245c6..22d1b28b4 100644 --- a/test/unit/utPretransformVertices.cpp +++ b/test/unit/utPretransformVertices.cpp @@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include +#include "PostProcessing/PretransformVertices.h" using namespace std; diff --git a/test/unit/utRemoveComponent.cpp b/test/unit/utRemoveComponent.cpp index 1b13989dd..a1ae7ef47 100644 --- a/test/unit/utRemoveComponent.cpp +++ b/test/unit/utRemoveComponent.cpp @@ -43,22 +43,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include -#include - +#include "PostProcessing/RemoveVCProcess.h" +#include "Material/MaterialSystem.h" using namespace std; using namespace Assimp; -class RemoveVCProcessTest : public ::testing::Test -{ +class RemoveVCProcessTest : public ::testing::Test { public: - virtual void SetUp(); virtual void TearDown(); protected: - RemoveVCProcess* piProcess; aiScene* pScene; }; diff --git a/test/unit/utRemoveRedundantMaterials.cpp b/test/unit/utRemoveRedundantMaterials.cpp index c3497595b..7810afbef 100644 --- a/test/unit/utRemoveRedundantMaterials.cpp +++ b/test/unit/utRemoveRedundantMaterials.cpp @@ -43,24 +43,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include -#include - +#include "PostProcessing/RemoveRedundantMaterials.h" +#include "Material/MaterialSystem.h" using namespace std; using namespace Assimp; -class RemoveRedundantMatsTest : public ::testing::Test -{ +class RemoveRedundantMatsTest : public ::testing::Test { public: - virtual void SetUp(); virtual void TearDown(); protected: - RemoveRedundantMatsProcess* piProcess; - aiScene* pcScene1; }; diff --git a/test/unit/utRemoveVCProcess.cpp b/test/unit/utRemoveVCProcess.cpp index 1eedf9842..8db5941d0 100644 --- a/test/unit/utRemoveVCProcess.cpp +++ b/test/unit/utRemoveVCProcess.cpp @@ -41,7 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ #include "UnitTestPCH.h" -#include "code/RemoveVCProcess.h" +#include "PostProcessing/RemoveVCProcess.h" + #include #include diff --git a/test/unit/utSIBImporter.cpp b/test/unit/utSIBImporter.cpp index 4d6a09783..582baef64 100644 --- a/test/unit/utSIBImporter.cpp +++ b/test/unit/utSIBImporter.cpp @@ -42,9 +42,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "UnitTestPCH.h" -#include "SIBImporter.h" +#include "SIB/SIBImporter.h" + #include #include + #include "AbstractImportExportBase.h" using namespace ::Assimp; diff --git a/test/unit/utSMDImportExport.cpp b/test/unit/utSMDImportExport.cpp index 500277099..dae490508 100644 --- a/test/unit/utSMDImportExport.cpp +++ b/test/unit/utSMDImportExport.cpp @@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "UnitTestPCH.h" -#include "SMDLoader.h" +#include "SMD/SMDLoader.h" #include #include #include "AbstractImportExportBase.h" diff --git a/test/unit/utScaleProcess.cpp b/test/unit/utScaleProcess.cpp index 13a184249..fe87daa8d 100644 --- a/test/unit/utScaleProcess.cpp +++ b/test/unit/utScaleProcess.cpp @@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ #include "UnitTestPCH.h" -#include "ScaleProcess.h" +#include "PostProcessing/ScaleProcess.h" #include "TestModelFactory.h" namespace Assimp { diff --git a/test/unit/utScenePreprocessor.cpp b/test/unit/utScenePreprocessor.cpp index 5e1af334c..2c181a90f 100644 --- a/test/unit/utScenePreprocessor.cpp +++ b/test/unit/utScenePreprocessor.cpp @@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#include "Common/ScenePreprocessor.h" using namespace std; using namespace Assimp; diff --git a/test/unit/utSharedPPData.cpp b/test/unit/utSharedPPData.cpp index 380235c58..53008a27a 100644 --- a/test/unit/utSharedPPData.cpp +++ b/test/unit/utSharedPPData.cpp @@ -43,21 +43,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include +#include "Common/BaseProcess.h" using namespace std; using namespace Assimp; -class SharedPPDataTest : public ::testing::Test -{ +class SharedPPDataTest : public ::testing::Test { public: - virtual void SetUp(); virtual void TearDown(); protected: - SharedPostProcessInfo* shared; }; diff --git a/test/unit/utSimd.cpp b/test/unit/utSimd.cpp index e7779a0ee..d6bd9fe90 100644 --- a/test/unit/utSimd.cpp +++ b/test/unit/utSimd.cpp @@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" -#include "simd.h" +#include "Common/simd.h" using namespace ::Assimp; diff --git a/test/unit/utSortByPType.cpp b/test/unit/utSortByPType.cpp index 4d9240c93..1aa9dad0a 100644 --- a/test/unit/utSortByPType.cpp +++ b/test/unit/utSortByPType.cpp @@ -43,29 +43,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include -#include +#include "Common/ScenePreprocessor.h" +#include "PostProcessing/SortByPTypeProcess.h" using namespace std; using namespace Assimp; -class SortByPTypeProcessTest : public ::testing::Test -{ +class SortByPTypeProcessTest : public ::testing::Test { public: - virtual void SetUp(); virtual void TearDown(); protected: - SortByPTypeProcess* process1; aiScene* scene; }; // ------------------------------------------------------------------------------------------------ -static unsigned int num[10][4] = - { +static unsigned int num[10][4] = { {0,0,0,1000}, {0,0,1000,0}, {0,1000,0,0}, diff --git a/test/unit/utSplitLargeMeshes.cpp b/test/unit/utSplitLargeMeshes.cpp index fced5df4b..fb3f2a037 100644 --- a/test/unit/utSplitLargeMeshes.cpp +++ b/test/unit/utSplitLargeMeshes.cpp @@ -43,16 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include - +#include "PostProcessing/SplitLargeMeshes.h" using namespace std; using namespace Assimp; -class SplitLargeMeshesTest : public ::testing::Test -{ +class SplitLargeMeshesTest : public ::testing::Test { public: - virtual void SetUp(); virtual void TearDown(); diff --git a/test/unit/utTriangulate.cpp b/test/unit/utTriangulate.cpp index 8c42000cd..c65e24a95 100644 --- a/test/unit/utTriangulate.cpp +++ b/test/unit/utTriangulate.cpp @@ -43,7 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "UnitTestPCH.h" #include -#include + +#include "PostProcessing/TriangulateProcess.h" using namespace std; diff --git a/test/unit/utVertexTriangleAdjacency.cpp b/test/unit/utVertexTriangleAdjacency.cpp index f15b0d21f..e48d3521e 100644 --- a/test/unit/utVertexTriangleAdjacency.cpp +++ b/test/unit/utVertexTriangleAdjacency.cpp @@ -42,19 +42,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "UnitTestPCH.h" -#include "assimp/types.h" -#include "assimp/mesh.h" - -#include +#include +#include +#include "Common/VertexTriangleAdjacency.h" using namespace std; using namespace Assimp; -class VTAdjacencyTest : public ::testing::Test -{ +class VTAdjacencyTest : public ::testing::Test { protected: - void checkMesh(const aiMesh& mesh); }; diff --git a/tools/assimp_cmd/CompareDump.cpp b/tools/assimp_cmd/CompareDump.cpp index 0ea0893f9..db7e3aada 100644 --- a/tools/assimp_cmd/CompareDump.cpp +++ b/tools/assimp_cmd/CompareDump.cpp @@ -53,7 +53,7 @@ const char* AICMD_MSG_CMPDUMP_HELP = "\tCompare two short dumps produced with \'assimp dump <..> -s\' for equality.\n" ; -#include "../../code/assbin_chunks.h" +#include "Common/assbin_chunks.h" //////////////////////////////////////////////////////////////////////////////////////////////////// #include "generic_inserter.hpp" @@ -62,7 +62,7 @@ const char* AICMD_MSG_CMPDUMP_HELP = #include #include #include -#include "../../include/assimp/ai_assert.h" +#include // get << for aiString template diff --git a/tools/assimp_cmd/Info.cpp b/tools/assimp_cmd/Info.cpp index b504083d3..d730b9308 100644 --- a/tools/assimp_cmd/Info.cpp +++ b/tools/assimp_cmd/Info.cpp @@ -317,10 +317,15 @@ int Assimp_Info (const char* const* params, unsigned int num) { return 1; } - // do maximum post-processing unless -r was specified + // Parse post-processing flags unless -r was specified ImportData import; if (!raw) { - import.ppFlags = aiProcessPreset_TargetRealtime_MaxQuality; + // get import flags + ProcessStandardArguments(import, params + 1, num - 1); + + //No custom post process flags defined, we set all the post process flags active + if(import.ppFlags == 0) + import.ppFlags |= aiProcessPreset_TargetRealtime_MaxQuality; } // import the main model diff --git a/tools/assimp_cmd/WriteDumb.cpp b/tools/assimp_cmd/WriteDumb.cpp index 0d6f58c60..559bf08c6 100644 --- a/tools/assimp_cmd/WriteDumb.cpp +++ b/tools/assimp_cmd/WriteDumb.cpp @@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "Main.h" -#include "../code/ProcessHelper.h" +#include "PostProcessing/ProcessHelper.h" const char* AICMD_MSG_DUMP_HELP = "assimp dump [] [-b] [-s] [-z] [common parameters]\n" @@ -59,7 +59,7 @@ const char* AICMD_MSG_DUMP_HELP = "\t -cfull Fires almost all post processing steps \n" ; -#include "../../code/assbin_chunks.h" +#include "Common/assbin_chunks.h" FILE* out = NULL; bool shortened = false; diff --git a/tools/assimp_view/Normals.cpp b/tools/assimp_view/Normals.cpp index 4ce706c6a..0ebd3dd5b 100644 --- a/tools/assimp_view/Normals.cpp +++ b/tools/assimp_view/Normals.cpp @@ -41,11 +41,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "assimp_view.h" -#include "GenFaceNormalsProcess.h" -#include "GenVertexNormalsProcess.h" -#include "JoinVerticesProcess.h" -#include "CalcTangentsProcess.h" -#include "MakeVerboseFormat.h" +#include "PostProcessing/GenFaceNormalsProcess.h" +#include "PostProcessing/GenVertexNormalsProcess.h" +#include "PostProcessing/JoinVerticesProcess.h" +#include "PostProcessing/CalcTangentsProcess.h" +#include "PostProcessing/MakeVerboseFormat.h" namespace AssimpView { diff --git a/tools/assimp_view/assimp_view.h b/tools/assimp_view/assimp_view.h index bed4c64c3..a32a62d04 100644 --- a/tools/assimp_view/assimp_view.h +++ b/tools/assimp_view/assimp_view.h @@ -72,9 +72,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include - -#include "../../code/MaterialSystem.h" // aiMaterial class -#include // ASSIMP_stricmp and ASSIMP_strincmp +#include "Material/MaterialSystem.h" // aiMaterial class +#include // ASSIMP_stricmp and ASSIMP_strincmp #include diff --git a/tools/assimp_view/stdafx.cpp b/tools/assimp_view/stdafx.cpp index 709f0fd9a..bbbb7e0c0 100644 --- a/tools/assimp_view/stdafx.cpp +++ b/tools/assimp_view/stdafx.cpp @@ -1,8 +1,8 @@ // stdafx.cpp : Quelldatei, die nur die Standard-Includes einbindet. // assimp_view.pch ist der vorkompilierte Header. -// stdafx.obj enthält die vorkompilierten Typinformationen. +// stdafx.obj enthält die vorkompilierten Typinformationen. #include "stdafx.h" -// TODO: Auf zusätzliche Header verweisen, die in STDAFX.H +// TODO: Auf zusätzliche Header verweisen, die in STDAFX.H // und nicht in dieser Datei erforderlich sind. diff --git a/tools/assimp_view/stdafx.h b/tools/assimp_view/stdafx.h index 35104d4b0..d3f4692cb 100644 --- a/tools/assimp_view/stdafx.h +++ b/tools/assimp_view/stdafx.h @@ -1,26 +1,26 @@ -// stdafx.h : Includedatei für Standardsystem-Includedateien -// oder häufig verwendete projektspezifische Includedateien, -// die nur in unregelmäßigen Abständen geändert werden. +// stdafx.h : Includedatei für Standardsystem-Includedateien +// oder häufig verwendete projektspezifische Includedateien, +// die nur in unregelmäßigen Abständen geändert werden. // #pragma once -// Ändern Sie folgende Definitionen für Plattformen, die älter als die unten angegebenen sind. -// In MSDN finden Sie die neuesten Informationen über die entsprechenden Werte für die unterschiedlichen Plattformen. -#ifndef WINVER // Lassen Sie die Verwendung spezifischer Features von Windows XP oder später zu. -# define WINVER 0x0501 // Ändern Sie dies in den geeigneten Wert für andere Versionen von Windows. +// Ändern Sie folgende Definitionen für Plattformen, die älter als die unten angegebenen sind. +// In MSDN finden Sie die neuesten Informationen über die entsprechenden Werte für die unterschiedlichen Plattformen. +#ifndef WINVER // Lassen Sie die Verwendung spezifischer Features von Windows XP oder später zu. +# define WINVER 0x0501 // Ändern Sie dies in den geeigneten Wert für andere Versionen von Windows. #endif -#ifndef _WIN32_WINNT // Lassen Sie die Verwendung spezifischer Features von Windows XP oder später zu. -# define _WIN32_WINNT 0x0501 // Ändern Sie dies in den geeigneten Wert für andere Versionen von Windows. +#ifndef _WIN32_WINNT // Lassen Sie die Verwendung spezifischer Features von Windows XP oder später zu. +# define _WIN32_WINNT 0x0501 // Ändern Sie dies in den geeigneten Wert für andere Versionen von Windows. #endif -#ifndef _WIN32_WINDOWS // Lassen Sie die Verwendung spezifischer Features von Windows 98 oder später zu. -# define _WIN32_WINDOWS 0x0410 // Ändern Sie dies in den geeigneten Wert für Windows Me oder höher. +#ifndef _WIN32_WINDOWS // Lassen Sie die Verwendung spezifischer Features von Windows 98 oder später zu. +# define _WIN32_WINDOWS 0x0410 // Ändern Sie dies in den geeigneten Wert für Windows Me oder höher. #endif -#ifndef _WIN32_IE // Lassen Sie die Verwendung spezifischer Features von IE 6.0 oder später zu. -#define _WIN32_IE 0x0600 // Ändern Sie dies in den geeigneten Wert für andere Versionen von IE. +#ifndef _WIN32_IE // Lassen Sie die Verwendung spezifischer Features von IE 6.0 oder später zu. +#define _WIN32_IE 0x0600 // Ändern Sie dies in den geeigneten Wert für andere Versionen von IE. #endif // Windows-Headerdateien: