Compare commits
1 Commits
master
...
kimkulling
Author | SHA1 | Date |
---|---|---|
Kim Kulling | 614911bb3b |
|
@ -7,10 +7,10 @@ on:
|
|||
branches: [ master ]
|
||||
|
||||
permissions:
|
||||
contents: write # to fetch code (actions/checkout),and release
|
||||
contents: read # to fetch code (actions/checkout)
|
||||
|
||||
jobs:
|
||||
build:
|
||||
job:
|
||||
name: ${{ matrix.name }}-build-and-test
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
|
@ -37,9 +37,6 @@ jobs:
|
|||
cc: gcc
|
||||
|
||||
steps:
|
||||
- name: ccache
|
||||
uses: hendrikmuhs/ccache-action@v1.2
|
||||
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
submodules: true
|
||||
|
@ -73,12 +70,12 @@ jobs:
|
|||
- name: Set Windows specific CMake arguments
|
||||
if: contains(matrix.name, 'windows')
|
||||
id: windows_extra_cmake_args
|
||||
run: echo ":set-output name=args::=-DASSIMP_BUILD_ASSIMP_TOOLS=1 -DASSIMP_BUILD_ASSIMP_VIEW=1" >> $GITHUB_OUTPUT
|
||||
run: echo "::set-output name=args::-DASSIMP_BUILD_ASSIMP_TOOLS=1 -DASSIMP_BUILD_ASSIMP_VIEW=1 -DASSIMP_BUILD_ZLIB=1"
|
||||
|
||||
- name: Set Hunter specific CMake arguments
|
||||
if: contains(matrix.name, 'hunter')
|
||||
id: hunter_extra_cmake_args
|
||||
run: echo "args=-DBUILD_SHARED_LIBS=OFF -DASSIMP_HUNTER_ENABLED=ON -DCMAKE_TOOLCHAIN_FILE=${{ github.workspace }}/cmake/polly/${{ matrix.toolchain }}.cmake" >> $GITHUB_OUTPUT
|
||||
run: echo "::set-output name=args::-DBUILD_SHARED_LIBS=OFF -DASSIMP_HUNTER_ENABLED=ON -DCMAKE_TOOLCHAIN_FILE=${{ github.workspace }}/cmake/polly/${{ matrix.toolchain }}.cmake"
|
||||
|
||||
- name: configure and build
|
||||
uses: lukka/run-cmake@v3
|
||||
|
@ -95,7 +92,7 @@ jobs:
|
|||
- name: Exclude certain tests in Hunter specific builds
|
||||
if: contains(matrix.name, 'hunter')
|
||||
id: hunter_extra_test_args
|
||||
run: echo "args=--gtest_filter=-utOpenGEXImportExport.Importissue1340_EmptyCameraObject:utColladaZaeImportExport.importBlenFromFileTest" >> $GITHUB_OUTPUT
|
||||
run: echo "::set-output name=args::--gtest_filter=-utOpenGEXImportExport.Importissue1340_EmptyCameraObject:utColladaZaeImportExport.importBlenFromFileTest"
|
||||
|
||||
- name: test
|
||||
run: cd build/bin && ./unit ${{ steps.hunter_extra_test_args.outputs.args }}
|
||||
|
@ -104,89 +101,5 @@ jobs:
|
|||
- uses: actions/upload-artifact@v4
|
||||
if: matrix.name == 'windows-msvc'
|
||||
with:
|
||||
name: 'assimp-bins-${{ matrix.name }}'
|
||||
path: build/bin/assimp*.exe
|
||||
|
||||
- uses: marvinpinto/action-automatic-releases@latest
|
||||
if: contains(matrix.name, 'windows-msvc-hunter')
|
||||
with:
|
||||
repo_token: "${{ secrets.GITHUB_TOKEN }}"
|
||||
automatic_release_tag: "master"
|
||||
prerelease: true
|
||||
title: "AutoRelease"
|
||||
files: |
|
||||
build/bin/assimp*.exe
|
||||
|
||||
create-release:
|
||||
needs: [build]
|
||||
runs-on: ubuntu-latest
|
||||
if: startsWith(github.ref, 'refs/tags/')
|
||||
steps:
|
||||
- id: create-release
|
||||
uses: actions/create-release@v1
|
||||
env:
|
||||
GITHUB_TOKEN: '${{secrets.GITHUB_TOKEN}}'
|
||||
with:
|
||||
tag_name: '${{github.ref}}'
|
||||
release_name: 'Release ${{github.ref}}'
|
||||
draft: false
|
||||
prerelease: true
|
||||
- run: |
|
||||
echo '${{steps.create-release.outputs.upload_url}}' > release_upload_url.txt
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: create-release
|
||||
path: release_upload_url.txt
|
||||
|
||||
upload-release:
|
||||
strategy:
|
||||
matrix:
|
||||
name: [ubuntu-latest-g++, macos-latest-clang++, windows-latest-cl.exe, ubuntu-latest-clang++, ubuntu-gcc-hunter, macos-clang-hunter, windows-msvc-hunter]
|
||||
# For Windows msvc, for Linux and macOS let's use the clang compiler, use gcc for Linux.
|
||||
include:
|
||||
- name: windows-latest-cl.exe
|
||||
os: windows-latest
|
||||
cxx: cl.exe
|
||||
cc: cl.exe
|
||||
- name: ubuntu-latest-clang++
|
||||
os: ubuntu-latest
|
||||
cxx: clang++
|
||||
cc: clang
|
||||
- name: macos-latest-clang++
|
||||
os: macos-latest
|
||||
cxx: clang++
|
||||
cc: clang
|
||||
- name: ubuntu-latest-g++
|
||||
os: ubuntu-latest
|
||||
cxx: g++
|
||||
cc: gcc
|
||||
- name: ubuntu-gcc-hunter
|
||||
os: ubuntu-latest
|
||||
toolchain: ninja-gcc-cxx17-fpic
|
||||
- name: macos-clang-hunter
|
||||
os: macos-latest
|
||||
toolchain: ninja-clang-cxx17-fpic
|
||||
- name: windows-msvc-hunter
|
||||
os: windows-latest
|
||||
toolchain: ninja-vs-win64-cxx17
|
||||
|
||||
needs: [create-release]
|
||||
runs-on: ubuntu-latest
|
||||
if: startsWith(github.ref, 'refs/tags/')
|
||||
steps:
|
||||
- uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
name: create-release
|
||||
- id: upload-url
|
||||
run: |
|
||||
echo "url=$(cat create-release/release_upload_url.txt)" >> $GITHUB_OUTPUT
|
||||
- uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: 'assimp-bins-${{ matrix.name }}-${{ github.sha }}'
|
||||
- uses: actions/upload-release-asset@v1
|
||||
env:
|
||||
GITHUB_TOKEN: '${{secrets.GITHUB_TOKEN}}'
|
||||
with:
|
||||
files: |
|
||||
*.zip
|
||||
|
||||
name: 'assimp-bins-${{ matrix.name }}-${{ github.sha }}'
|
||||
path: build/bin
|
||||
|
|
|
@ -120,7 +120,3 @@ tools/assimp_qt_viewer/ui_mainwindow.h
|
|||
|
||||
#Generated directory
|
||||
generated/*
|
||||
|
||||
# 3rd party cloned repos/tarballs etc
|
||||
# tinyusdz repo, automatically cloned via CMake
|
||||
contrib/tinyusdz/autoclone
|
||||
|
|
|
@ -40,22 +40,6 @@ SET(CMAKE_POLICY_DEFAULT_CMP0092 NEW)
|
|||
|
||||
CMAKE_MINIMUM_REQUIRED( VERSION 3.22 )
|
||||
|
||||
# Experimental USD importer: disabled, need to opt-in
|
||||
# Note: assimp github PR automatic checks will fail the PR due to compiler warnings in
|
||||
# the external, 3rd party tinyusdz code which isn't technically part of the PR since it's
|
||||
# auto-cloned during build; so MUST disable the feature or the PR will be rejected
|
||||
option(ASSIMP_BUILD_USD_IMPORTER "Enable USD file import" off)
|
||||
option(ASSIMP_BUILD_USD_VERBOSE_LOGS "Enable verbose USD import debug logging" off)
|
||||
option(ASSIMP_BUILD_USE_CCACHE "Use ccache to speed up compilation." on)
|
||||
|
||||
if(ASSIMP_BUILD_USE_CCACHE)
|
||||
find_program(CCACHE_PATH ccache)
|
||||
if (CCACHE_PATH)
|
||||
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_PATH})
|
||||
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_PATH})
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Disabled importers: m3d for 5.1 or later
|
||||
ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_IMPORTER)
|
||||
ADD_DEFINITIONS( -DASSIMP_BUILD_NO_M3D_EXPORTER)
|
||||
|
@ -71,7 +55,7 @@ IF(ASSIMP_HUNTER_ENABLED)
|
|||
add_definitions(-DASSIMP_USE_HUNTER)
|
||||
ENDIF()
|
||||
|
||||
PROJECT(Assimp VERSION 5.4.3)
|
||||
PROJECT(Assimp VERSION 5.4.1)
|
||||
|
||||
# All supported options ###############################################
|
||||
|
||||
|
@ -163,7 +147,7 @@ IF (WIN32)
|
|||
|
||||
IF(MSVC)
|
||||
OPTION( ASSIMP_INSTALL_PDB
|
||||
"Create MSVC debug symbol files and add to Install target."
|
||||
"Install MSVC debug files."
|
||||
ON )
|
||||
IF(NOT (MSVC_VERSION LESS 1900))
|
||||
# Multibyte character set has been deprecated since at least MSVC2015 (possibly earlier)
|
||||
|
@ -278,7 +262,7 @@ IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT MINGW AND NOT HAIKU)
|
|||
IF(NOT ASSIMP_HUNTER_ENABLED)
|
||||
SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
||||
ENDIF()
|
||||
|
||||
|
||||
IF(CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 13)
|
||||
MESSAGE(STATUS "GCC13 detected disabling \"-Wdangling-reference\" in Cpp files as it appears to be a false positive")
|
||||
ADD_COMPILE_OPTIONS("$<$<COMPILE_LANGUAGE:CXX>:-Wno-dangling-reference>")
|
||||
|
@ -300,23 +284,16 @@ ELSEIF(MSVC)
|
|||
ELSE() # msvc
|
||||
ADD_COMPILE_OPTIONS(/MP /bigobj)
|
||||
ENDIF()
|
||||
|
||||
|
||||
# disable "elements of array '' will be default initialized" warning on MSVC2013
|
||||
IF(MSVC12)
|
||||
ADD_COMPILE_OPTIONS(/wd4351)
|
||||
ADD_COMPILE_OPTIONS(/wd4351)
|
||||
ENDIF()
|
||||
# supress warning for double to float conversion if Double precision is activated
|
||||
ADD_COMPILE_OPTIONS(/wd4244)
|
||||
ADD_COMPILE_OPTIONS(/wd4244)
|
||||
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /D_DEBUG /Zi /Od")
|
||||
# Allow user to disable PDBs
|
||||
if(ASSIMP_INSTALL_PDB)
|
||||
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
|
||||
SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG:FULL /PDBALTPATH:%_PDB% /OPT:REF /OPT:ICF")
|
||||
elseif((GENERATOR_IS_MULTI_CONFIG) OR (CMAKE_BUILD_TYPE MATCHES Release))
|
||||
message("-- MSVC PDB generation disabled. Release binary will not be debuggable.")
|
||||
endif()
|
||||
# Source code is encoded in UTF-8
|
||||
ADD_COMPILE_OPTIONS(/source-charset:utf-8)
|
||||
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
|
||||
SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG:FULL /PDBALTPATH:%_PDB% /OPT:REF /OPT:ICF")
|
||||
ELSEIF (CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
|
||||
IF(NOT ASSIMP_HUNTER_ENABLED)
|
||||
SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
||||
|
@ -353,7 +330,7 @@ ENDIF()
|
|||
|
||||
IF (ASSIMP_COVERALLS)
|
||||
MESSAGE(STATUS "Coveralls enabled")
|
||||
|
||||
|
||||
INCLUDE(Coveralls)
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
|
||||
|
@ -361,7 +338,7 @@ ENDIF()
|
|||
|
||||
IF (ASSIMP_ASAN)
|
||||
MESSAGE(STATUS "AddressSanitizer enabled")
|
||||
|
||||
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address")
|
||||
ENDIF()
|
||||
|
@ -659,7 +636,7 @@ ELSE()
|
|||
IF ( ASSIMP_BUILD_DRACO )
|
||||
# Primarily for glTF v2
|
||||
# Enable Draco glTF feature set
|
||||
set(DRACO_GLTF_BITSTREAM ON CACHE BOOL "" FORCE)
|
||||
set(DRACO_GLTF ON CACHE BOOL "" FORCE)
|
||||
# Disable unnecessary or omitted components
|
||||
set(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
|
||||
set(DRACO_WASM OFF CACHE BOOL "" FORCE)
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
FROM ubuntu:22.04
|
||||
|
||||
RUN apt-get update && apt-get install --no-install-recommends -y ninja-build \
|
||||
RUN apt-get update && apt-get install -y ninja-build \
|
||||
git cmake build-essential software-properties-common
|
||||
|
||||
RUN add-apt-repository ppa:ubuntu-toolchain-r/test && apt-get update
|
||||
|
|
|
@ -26,11 +26,12 @@ Clone [our model database](https://github.com/assimp/assimp-mdb).
|
|||
|
||||
### Communities ###
|
||||
- Ask questions at [the Assimp Discussion Board](https://github.com/assimp/assimp/discussions).
|
||||
- Find us on [https://discord.gg/s9KJfaem](https://discord.gg/kKazXMXDy2)
|
||||
- Ask [the Assimp community on Reddit](https://www.reddit.com/r/Assimp/).
|
||||
- Ask on [StackOverflow with the assimp-tag](http://stackoverflow.com/questions/tagged/assimp?sort=newest).
|
||||
- Nothing has worked? File a question or an issue-report at [The Assimp-Issue Tracker](https://github.com/assimp/assimp/issues)
|
||||
|
||||
And we also have a Gitter-channel:Gitter [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
|
||||
|
||||
#### Supported file formats ####
|
||||
See [the complete list of supported formats](https://github.com/assimp/assimp/blob/master/doc/Fileformats.md).
|
||||
|
||||
|
|
|
@ -643,17 +643,11 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
|
|||
}
|
||||
|
||||
// Allocate storage for children
|
||||
const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
|
||||
|
||||
pcOut->mNumChildren = size;
|
||||
if (size == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
pcOut->mNumChildren = (unsigned int)pcIn->mChildren.size();
|
||||
pcOut->mChildren = new aiNode *[pcIn->mChildren.size()];
|
||||
|
||||
// Recursively process all children
|
||||
|
||||
const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
|
||||
for (unsigned int i = 0; i < size; ++i) {
|
||||
pcOut->mChildren[i] = new aiNode();
|
||||
pcOut->mChildren[i]->mParent = pcOut;
|
||||
|
|
|
@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <assimp/StringComparison.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <assimp/Exporter.hpp>
|
||||
#include <assimp/Exceptional.h>
|
||||
#include <assimp/IOSystem.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
|
|
@ -365,13 +365,14 @@ struct Texture {
|
|||
#ifdef _MSC_VER
|
||||
#pragma warning(pop)
|
||||
#endif // _MSC_VER
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** Helper structure representing a 3ds material */
|
||||
struct Material {
|
||||
//! Default constructor has been deleted
|
||||
Material() :
|
||||
mName(),
|
||||
mDiffuse(0.6f, 0.6f, 0.6f),
|
||||
mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
|
||||
mSpecularExponent(ai_real(0.0)),
|
||||
mShininessStrength(ai_real(1.0)),
|
||||
mShading(Discreet3DS::Gouraud),
|
||||
|
@ -384,7 +385,7 @@ struct Material {
|
|||
//! Constructor with explicit name
|
||||
explicit Material(const std::string &name) :
|
||||
mName(name),
|
||||
mDiffuse(0.6f, 0.6f, 0.6f),
|
||||
mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
|
||||
mSpecularExponent(ai_real(0.0)),
|
||||
mShininessStrength(ai_real(1.0)),
|
||||
mShading(Discreet3DS::Gouraud),
|
||||
|
|
|
@ -249,10 +249,10 @@ void D3MFExporter::writeBaseMaterials() {
|
|||
if (color.r <= 1 && color.g <= 1 && color.b <= 1 && color.a <= 1) {
|
||||
|
||||
hexDiffuseColor = ai_rgba2hex(
|
||||
(int)(((ai_real)color.r) * 255),
|
||||
(int)(((ai_real)color.g) * 255),
|
||||
(int)(((ai_real)color.b) * 255),
|
||||
(int)(((ai_real)color.a) * 255),
|
||||
(int)((ai_real)color.r) * 255,
|
||||
(int)((ai_real)color.g) * 255,
|
||||
(int)((ai_real)color.b) * 255,
|
||||
(int)((ai_real)color.a) * 255,
|
||||
true);
|
||||
|
||||
} else {
|
||||
|
|
|
@ -57,8 +57,8 @@ static constexpr size_t ColRGBA_Len = 9;
|
|||
static constexpr size_t ColRGB_Len = 7;
|
||||
|
||||
// format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
|
||||
bool validateColorString(const std::string color) {
|
||||
const size_t len = color.size();
|
||||
bool validateColorString(const char *color) {
|
||||
const size_t len = strlen(color);
|
||||
if (ColRGBA_Len != len && ColRGB_Len != len) {
|
||||
return false;
|
||||
}
|
||||
|
@ -157,8 +157,8 @@ aiMatrix4x4 parseTransformMatrix(const std::string& matrixStr) {
|
|||
return transformMatrix;
|
||||
}
|
||||
|
||||
bool parseColor(const std::string &color, aiColor4D &diffuse) {
|
||||
if (color.empty()) {
|
||||
bool parseColor(const char *color, aiColor4D &diffuse) {
|
||||
if (nullptr == color) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -178,7 +178,7 @@ bool parseColor(const std::string &color, aiColor4D &diffuse) {
|
|||
|
||||
char b[3] = { color[5], color[6], '\0' };
|
||||
diffuse.b = static_cast<ai_real>(strtol(b, nullptr, 16)) / ai_real(255.0);
|
||||
const size_t len = color.size();
|
||||
const size_t len = strlen(color);
|
||||
if (ColRGB_Len == len) {
|
||||
return true;
|
||||
}
|
||||
|
|
|
@ -178,6 +178,28 @@ bool AMFImporter::XML_SearchNode(const std::string &nodeName) {
|
|||
return nullptr != mXmlParser->findNode(nodeName);
|
||||
}
|
||||
|
||||
void AMFImporter::ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString) {
|
||||
size_t instr_len;
|
||||
|
||||
pOutString.clear();
|
||||
instr_len = strlen(pInStr);
|
||||
if (!instr_len) return;
|
||||
|
||||
pOutString.reserve(instr_len * 3 / 2);
|
||||
// check and correct floats in format ".x". Must be "x.y".
|
||||
if (pInStr[0] == '.') pOutString.push_back('0');
|
||||
|
||||
pOutString.push_back(pInStr[0]);
|
||||
for (size_t ci = 1; ci < instr_len; ci++) {
|
||||
if ((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t'))) {
|
||||
pOutString.push_back('0');
|
||||
pOutString.push_back('.');
|
||||
} else {
|
||||
pOutString.push_back(pInStr[ci]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool ParseHelper_Decode_Base64_IsBase64(const char pChar) {
|
||||
return (isalnum((unsigned char)pChar) || (pChar == '+') || (pChar == '/'));
|
||||
}
|
||||
|
@ -191,10 +213,7 @@ void AMFImporter::ParseHelper_Decode_Base64(const std::string &pInputBase64, std
|
|||
uint8_t arr4[4], arr3[3];
|
||||
|
||||
// check input data
|
||||
if (pInputBase64.size() % 4) {
|
||||
throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
|
||||
}
|
||||
|
||||
if (pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
|
||||
// prepare output place
|
||||
pOutputData.clear();
|
||||
pOutputData.reserve(pInputBase64.size() / 4 * 3);
|
||||
|
@ -384,17 +403,17 @@ void AMFImporter::ParseNode_Instance(XmlNode &node) {
|
|||
for (auto ¤tNode : node.children()) {
|
||||
const std::string ¤tName = currentNode.name();
|
||||
if (currentName == "deltax") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Delta.x);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Delta.x);
|
||||
} else if (currentName == "deltay") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Delta.y);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Delta.y);
|
||||
} else if (currentName == "deltaz") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Delta.z);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Delta.z);
|
||||
} else if (currentName == "rx") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Delta.x);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Delta.x);
|
||||
} else if (currentName == "ry") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Delta.y);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Delta.y);
|
||||
} else if (currentName == "rz") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Delta.z);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Delta.z);
|
||||
}
|
||||
}
|
||||
ParseHelper_Node_Exit();
|
||||
|
|
|
@ -168,6 +168,7 @@ public:
|
|||
AI_WONT_RETURN void Throw_ID_NotFound(const std::string &pID) const AI_WONT_RETURN_SUFFIX;
|
||||
void XML_CheckNode_MustHaveChildren(pugi::xml_node &node);
|
||||
bool XML_SearchNode(const std::string &nodeName);
|
||||
void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString);
|
||||
AMFImporter(const AMFImporter &pScene) = delete;
|
||||
AMFImporter &operator=(const AMFImporter &pScene) = delete;
|
||||
|
||||
|
|
|
@ -167,11 +167,11 @@ void AMFImporter::ParseNode_Coordinates(XmlNode &node) {
|
|||
AMFCoordinates &als = *((AMFCoordinates *)ne); // alias for convenience
|
||||
const std::string ¤tName = ai_tolower(currentNode.name());
|
||||
if (currentName == "x") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Coordinate.x);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Coordinate.x);
|
||||
} else if (currentName == "y") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Coordinate.y);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Coordinate.y);
|
||||
} else if (currentName == "z") {
|
||||
XmlParser::getValueAsReal(currentNode, als.Coordinate.z);
|
||||
XmlParser::getValueAsFloat(currentNode, als.Coordinate.z);
|
||||
}
|
||||
}
|
||||
ParseHelper_Node_Exit();
|
||||
|
|
|
@ -263,25 +263,26 @@ void AMFImporter::ParseNode_TexMap(XmlNode &node, const bool pUseOldName) {
|
|||
const std::string &name = currentNode.name();
|
||||
if (name == "utex1") {
|
||||
read_flag[0] = true;
|
||||
XmlParser::getValueAsReal(node, als.TextureCoordinate[0].x);
|
||||
XmlParser::getValueAsFloat(node, als.TextureCoordinate[0].x);
|
||||
} else if (name == "utex2") {
|
||||
read_flag[1] = true;
|
||||
XmlParser::getValueAsReal(node, als.TextureCoordinate[1].x);
|
||||
XmlParser::getValueAsFloat(node, als.TextureCoordinate[1].x);
|
||||
} else if (name == "utex3") {
|
||||
read_flag[2] = true;
|
||||
XmlParser::getValueAsReal(node, als.TextureCoordinate[2].x);
|
||||
XmlParser::getValueAsFloat(node, als.TextureCoordinate[2].x);
|
||||
} else if (name == "vtex1") {
|
||||
read_flag[3] = true;
|
||||
XmlParser::getValueAsReal(node, als.TextureCoordinate[0].y);
|
||||
XmlParser::getValueAsFloat(node, als.TextureCoordinate[0].y);
|
||||
} else if (name == "vtex2") {
|
||||
read_flag[4] = true;
|
||||
XmlParser::getValueAsReal(node, als.TextureCoordinate[1].y);
|
||||
XmlParser::getValueAsFloat(node, als.TextureCoordinate[1].y);
|
||||
} else if (name == "vtex3") {
|
||||
read_flag[5] = true;
|
||||
XmlParser::getValueAsReal(node, als.TextureCoordinate[2].y);
|
||||
XmlParser::getValueAsFloat(node, als.TextureCoordinate[2].y);
|
||||
}
|
||||
}
|
||||
ParseHelper_Node_Exit();
|
||||
|
||||
} else {
|
||||
for (pugi::xml_attribute &attr : node.attributes()) {
|
||||
const std::string name = attr.name();
|
||||
|
|
|
@ -56,6 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
/// \class CAMFImporter_NodeElement
|
||||
/// Base class for elements of nodes.
|
||||
class AMFNodeElementBase {
|
||||
public:
|
||||
|
@ -105,6 +106,7 @@ protected:
|
|||
}
|
||||
}; // class IAMFImporter_NodeElement
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Constellation
|
||||
/// A collection of objects or constellations with specific relative locations.
|
||||
struct AMFConstellation : public AMFNodeElementBase {
|
||||
/// Constructor.
|
||||
|
@ -114,6 +116,7 @@ struct AMFConstellation : public AMFNodeElementBase {
|
|||
|
||||
}; // struct CAMFImporter_NodeElement_Constellation
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Instance
|
||||
/// Part of constellation.
|
||||
struct AMFInstance : public AMFNodeElementBase {
|
||||
|
||||
|
@ -132,6 +135,7 @@ struct AMFInstance : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Instance, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Metadata
|
||||
/// Structure that define metadata node.
|
||||
struct AMFMetadata : public AMFNodeElementBase {
|
||||
|
||||
|
@ -144,6 +148,7 @@ struct AMFMetadata : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Metadata, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Root
|
||||
/// Structure that define root node.
|
||||
struct AMFRoot : public AMFNodeElementBase {
|
||||
|
||||
|
@ -156,6 +161,7 @@ struct AMFRoot : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Root, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Color
|
||||
/// Structure that define object node.
|
||||
struct AMFColor : public AMFNodeElementBase {
|
||||
bool Composed; ///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
|
||||
|
@ -171,6 +177,7 @@ struct AMFColor : public AMFNodeElementBase {
|
|||
}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Material
|
||||
/// Structure that define material node.
|
||||
struct AMFMaterial : public AMFNodeElementBase {
|
||||
|
||||
|
@ -180,6 +187,7 @@ struct AMFMaterial : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Material, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Object
|
||||
/// Structure that define object node.
|
||||
struct AMFObject : public AMFNodeElementBase {
|
||||
|
||||
|
@ -198,6 +206,7 @@ struct AMFMesh : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Mesh, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Vertex
|
||||
/// Structure that define vertex node.
|
||||
struct AMFVertex : public AMFNodeElementBase {
|
||||
/// Constructor.
|
||||
|
@ -206,6 +215,7 @@ struct AMFVertex : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Vertex, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Edge
|
||||
/// Structure that define edge node.
|
||||
struct AMFEdge : public AMFNodeElementBase {
|
||||
/// Constructor.
|
||||
|
@ -214,6 +224,7 @@ struct AMFEdge : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Edge, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Vertices
|
||||
/// Structure that define vertices node.
|
||||
struct AMFVertices : public AMFNodeElementBase {
|
||||
/// Constructor.
|
||||
|
@ -222,6 +233,7 @@ struct AMFVertices : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Vertices, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Volume
|
||||
/// Structure that define volume node.
|
||||
struct AMFVolume : public AMFNodeElementBase {
|
||||
std::string MaterialID; ///< Which material to use.
|
||||
|
@ -233,6 +245,7 @@ struct AMFVolume : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Volume, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Coordinates
|
||||
/// Structure that define coordinates node.
|
||||
struct AMFCoordinates : public AMFNodeElementBase {
|
||||
aiVector3D Coordinate; ///< Coordinate.
|
||||
|
@ -243,6 +256,7 @@ struct AMFCoordinates : public AMFNodeElementBase {
|
|||
AMFNodeElementBase(ENET_Coordinates, pParent) {}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_TexMap
|
||||
/// Structure that define texture coordinates node.
|
||||
struct AMFTexMap : public AMFNodeElementBase {
|
||||
aiVector3D TextureCoordinate[3]; ///< Texture coordinates.
|
||||
|
@ -259,6 +273,7 @@ struct AMFTexMap : public AMFNodeElementBase {
|
|||
}
|
||||
};
|
||||
|
||||
/// \struct CAMFImporter_NodeElement_Triangle
|
||||
/// Structure that define triangle node.
|
||||
struct AMFTriangle : public AMFNodeElementBase {
|
||||
size_t V[3]; ///< Triangle vertices.
|
||||
|
|
|
@ -224,8 +224,7 @@ size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string &
|
|||
}
|
||||
|
||||
// Create format hint.
|
||||
constexpr char templateColor[] = "rgba0000";
|
||||
memcpy(converted_texture.FormatHint, templateColor, 8);
|
||||
strcpy(converted_texture.FormatHint, "rgba0000"); // copy initial string.
|
||||
if (!r.empty()) converted_texture.FormatHint[4] = '8';
|
||||
if (!g.empty()) converted_texture.FormatHint[5] = '8';
|
||||
if (!b.empty()) converted_texture.FormatHint[6] = '8';
|
||||
|
@ -868,7 +867,7 @@ nl_clean_loop:
|
|||
pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
|
||||
pScene->mTextures[idx]->pcData = (aiTexel *)tex_convd.Data;
|
||||
// texture format description.
|
||||
strncpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint, HINTMAXTEXTURELEN);
|
||||
strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
|
||||
idx++;
|
||||
} // for(const SPP_Texture& tex_convd: mTexture_Converted)
|
||||
|
||||
|
|
|
@ -124,7 +124,7 @@ void ASEImporter::InternReadFile(const std::string &pFile,
|
|||
// Allocate storage and copy the contents of the file to a memory buffer
|
||||
std::vector<char> mBuffer2;
|
||||
TextFileToBuffer(file.get(), mBuffer2);
|
||||
const size_t fileSize = mBuffer2.size();
|
||||
|
||||
this->mBuffer = &mBuffer2[0];
|
||||
this->pcScene = pScene;
|
||||
|
||||
|
@ -146,7 +146,7 @@ void ASEImporter::InternReadFile(const std::string &pFile,
|
|||
};
|
||||
|
||||
// Construct an ASE parser and parse the file
|
||||
ASE::Parser parser(mBuffer, fileSize, defaultFormat);
|
||||
ASE::Parser parser(mBuffer, defaultFormat);
|
||||
mParser = &parser;
|
||||
mParser->Parse();
|
||||
|
||||
|
@ -446,9 +446,10 @@ void ASEImporter::BuildLights() {
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes, aiNode *pcParent, const std::string &name) {
|
||||
void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
|
||||
aiNode *pcParent, const char *szName) {
|
||||
aiMatrix4x4 m;
|
||||
AddNodes(nodes, pcParent, name, m);
|
||||
AddNodes(nodes, pcParent, szName, m);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
@ -505,9 +506,10 @@ void ASEImporter::AddMeshes(const ASE::BaseNode *snode, aiNode *node) {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Add child nodes to a given parent node
|
||||
void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes, aiNode *pcParent, const std::string &name,
|
||||
void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
|
||||
aiNode *pcParent, const char *szName,
|
||||
const aiMatrix4x4 &mat) {
|
||||
const size_t len = name.size();
|
||||
const size_t len = szName ? ::strlen(szName) : 0;
|
||||
ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS);
|
||||
|
||||
// Receives child nodes for the pcParent node
|
||||
|
@ -517,18 +519,16 @@ void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes, aiNode *pcParen
|
|||
// which has *us* as parent.
|
||||
for (std::vector<BaseNode *>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
|
||||
const BaseNode *snode = *it;
|
||||
if (!name.empty()) {
|
||||
if (len != snode->mParent.length() || name != snode->mParent.c_str()) {
|
||||
if (szName) {
|
||||
if (len != snode->mParent.length() || ::strcmp(szName, snode->mParent.c_str()))
|
||||
continue;
|
||||
}
|
||||
} else if (snode->mParent.length()) {
|
||||
} else if (snode->mParent.length())
|
||||
continue;
|
||||
}
|
||||
|
||||
(*it)->mProcessed = true;
|
||||
|
||||
// Allocate a new node and add it to the output data structure
|
||||
apcNodes.push_back(new aiNode);
|
||||
apcNodes.push_back(new aiNode());
|
||||
aiNode *node = apcNodes.back();
|
||||
|
||||
node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node"));
|
||||
|
@ -541,7 +541,7 @@ void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes, aiNode *pcParen
|
|||
|
||||
// Add sub nodes - prevent stack overflow due to recursive parenting
|
||||
if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) {
|
||||
AddNodes(nodes, node, node->mName.C_Str(), snode->mTransform);
|
||||
AddNodes(nodes, node, node->mName.data, snode->mTransform);
|
||||
}
|
||||
|
||||
// Further processing depends on the type of the node
|
||||
|
@ -619,8 +619,7 @@ void ASEImporter::BuildNodes(std::vector<BaseNode *> &nodes) {
|
|||
}
|
||||
|
||||
// add all nodes
|
||||
static const std::string none = "";
|
||||
AddNodes(nodes, ch, none);
|
||||
AddNodes(nodes, ch, nullptr);
|
||||
|
||||
// now iterate through al nodes and find those that have not yet
|
||||
// been added to the nodegraph (= their parent could not be recognized)
|
||||
|
|
|
@ -153,13 +153,13 @@ private:
|
|||
* \param matrix Current transform
|
||||
*/
|
||||
void AddNodes(const std::vector<ASE::BaseNode*>& nodes,
|
||||
aiNode* pcParent, const std::string &name);
|
||||
aiNode* pcParent,const char* szName);
|
||||
|
||||
void AddNodes(const std::vector<ASE::BaseNode*>& nodes,
|
||||
aiNode* pcParent, const std::string &name,
|
||||
aiNode* pcParent,const char* szName,
|
||||
const aiMatrix4x4& matrix);
|
||||
|
||||
void AddMeshes(const ASE::BaseNode* snode, aiNode* node);
|
||||
void AddMeshes(const ASE::BaseNode* snode,aiNode* node);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Generate a default material and add it to the parser's list
|
||||
|
@ -188,4 +188,5 @@ protected:
|
|||
|
||||
} // end of namespace Assimp
|
||||
|
||||
|
||||
#endif // AI_3DSIMPORTER_H_INC
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -391,11 +391,11 @@ public:
|
|||
// -------------------------------------------------------------------
|
||||
//! Construct a parser from a given input file which is
|
||||
//! guaranteed to be terminated with zero.
|
||||
//! @param file The name of the input file.
|
||||
//! @param szFile Input file
|
||||
//! @param fileFormatDefault Assumed file format version. If the
|
||||
//! file format is specified in the file the new value replaces
|
||||
//! the default value.
|
||||
Parser(const char *file, size_t fileLen, unsigned int fileFormatDefault);
|
||||
Parser(const char *szFile, unsigned int fileFormatDefault);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
//! Parses the file into the parsers internal representation
|
||||
|
@ -553,15 +553,13 @@ private:
|
|||
//! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...)
|
||||
//! \param apOut Output buffer (3 floats)
|
||||
//! \param rIndexOut Output index
|
||||
void ParseLV4MeshRealTriple(ai_real *apOut, unsigned int &rIndexOut);
|
||||
void ParseLV4MeshFloatTriple(float *apOut, unsigned int &rIndexOut);
|
||||
void ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
//! Parse a *MESH_VERT block in a file
|
||||
//! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...)
|
||||
//! \param apOut Output buffer (3 floats)
|
||||
void ParseLV4MeshRealTriple(ai_real *apOut);
|
||||
void ParseLV4MeshFloatTriple(float *apOut);
|
||||
void ParseLV4MeshFloatTriple(ai_real *apOut);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
//! Parse a *MESH_TFACE block in a file
|
||||
|
@ -579,8 +577,7 @@ private:
|
|||
// -------------------------------------------------------------------
|
||||
//! Parse a single float element
|
||||
//! \param fOut Output float
|
||||
void ParseLV4MeshReal(ai_real &fOut);
|
||||
void ParseLV4MeshFloat(float &fOut);
|
||||
void ParseLV4MeshFloat(ai_real &fOut);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
//! Parse a single int element
|
||||
|
@ -620,8 +617,11 @@ private:
|
|||
bool ParseString(std::string &out, const char *szName);
|
||||
|
||||
public:
|
||||
const char *mFilePtr; ////< Pointer to current data
|
||||
const char *mEnd; ///< The end pointer of the file data
|
||||
//! Pointer to current data
|
||||
const char *filePtr;
|
||||
|
||||
/// The end pointer of the file data
|
||||
const char *mEnd;
|
||||
|
||||
//! background color to be passed to the viewer
|
||||
//! QNAN if none was found
|
||||
|
|
|
@ -372,11 +372,9 @@ aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fi
|
|||
}
|
||||
|
||||
// add children recursively
|
||||
if (!root.temp_children.empty()) {
|
||||
nd->mChildren = new aiNode *[root.temp_children.size()]();
|
||||
for (const Node *n : root.temp_children) {
|
||||
(nd->mChildren[nd->mNumChildren++] = BuildNodes(*n, scin, fill))->mParent = nd;
|
||||
}
|
||||
nd->mChildren = new aiNode *[root.temp_children.size()]();
|
||||
for (const Node *n : root.temp_children) {
|
||||
(nd->mChildren[nd->mNumChildren++] = BuildNodes(*n, scin, fill))->mParent = nd;
|
||||
}
|
||||
|
||||
return nd;
|
||||
|
|
|
@ -625,14 +625,16 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
|
|||
}
|
||||
|
||||
// same for texture coords, as many as we have
|
||||
for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
|
||||
// empty slots are not allowed, need to pack and adjust UV indexes accordingly
|
||||
for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
|
||||
if (pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices) {
|
||||
dstMesh->mTextureCoords[a] = new aiVector3D[numVertices];
|
||||
dstMesh->mTextureCoords[real] = new aiVector3D[numVertices];
|
||||
for (size_t b = 0; b < numVertices; ++b) {
|
||||
dstMesh->mTextureCoords[a][b] = pSrcMesh->mTexCoords[a][pStartVertex + b];
|
||||
dstMesh->mTextureCoords[real][b] = pSrcMesh->mTexCoords[a][pStartVertex + b];
|
||||
}
|
||||
|
||||
dstMesh->mNumUVComponents[a] = pSrcMesh->mNumUVComponents[a];
|
||||
dstMesh->mNumUVComponents[real] = pSrcMesh->mNumUVComponents[a];
|
||||
++real;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -968,34 +968,34 @@ void ColladaParser::ReadLight(XmlNode &node, Collada::Light &pLight) {
|
|||
content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.b);
|
||||
SkipSpacesAndLineEnd(&content, end);
|
||||
} else if (currentName == "constant_attenuation") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mAttConstant);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mAttConstant);
|
||||
} else if (currentName == "linear_attenuation") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mAttLinear);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mAttLinear);
|
||||
} else if (currentName == "quadratic_attenuation") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mAttQuadratic);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mAttQuadratic);
|
||||
} else if (currentName == "falloff_angle") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mFalloffAngle);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle);
|
||||
} else if (currentName == "falloff_exponent") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mFalloffExponent);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mFalloffExponent);
|
||||
}
|
||||
// FCOLLADA extensions
|
||||
// -------------------------------------------------------
|
||||
else if (currentName == "outer_cone") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mOuterAngle);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
|
||||
} else if (currentName == "penumbra_angle") { // this one is deprecated, now calculated using outer_cone
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mPenumbraAngle);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mPenumbraAngle);
|
||||
} else if (currentName == "intensity") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mIntensity);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mIntensity);
|
||||
}
|
||||
else if (currentName == "falloff") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mOuterAngle);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
|
||||
} else if (currentName == "hotspot_beam") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mFalloffAngle);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle);
|
||||
}
|
||||
// OpenCOLLADA extensions
|
||||
// -------------------------------------------------------
|
||||
else if (currentName == "decay_falloff") {
|
||||
XmlParser::getValueAsReal(currentNode, pLight.mOuterAngle);
|
||||
XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1010,15 +1010,15 @@ void ColladaParser::ReadCamera(XmlNode &node, Collada::Camera &camera) {
|
|||
if (currentName == "orthographic") {
|
||||
camera.mOrtho = true;
|
||||
} else if (currentName == "xfov" || currentName == "xmag") {
|
||||
XmlParser::getValueAsReal(currentNode, camera.mHorFov);
|
||||
XmlParser::getValueAsFloat(currentNode, camera.mHorFov);
|
||||
} else if (currentName == "yfov" || currentName == "ymag") {
|
||||
XmlParser::getValueAsReal(currentNode, camera.mVerFov);
|
||||
XmlParser::getValueAsFloat(currentNode, camera.mVerFov);
|
||||
} else if (currentName == "aspect_ratio") {
|
||||
XmlParser::getValueAsReal(currentNode, camera.mAspect);
|
||||
XmlParser::getValueAsFloat(currentNode, camera.mAspect);
|
||||
} else if (currentName == "znear") {
|
||||
XmlParser::getValueAsReal(currentNode, camera.mZNear);
|
||||
XmlParser::getValueAsFloat(currentNode, camera.mZNear);
|
||||
} else if (currentName == "zfar") {
|
||||
XmlParser::getValueAsReal(currentNode, camera.mZFar);
|
||||
XmlParser::getValueAsFloat(currentNode, camera.mZFar);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1170,15 +1170,15 @@ void ColladaParser::ReadSamplerProperties(XmlNode &node, Sampler &out) {
|
|||
} else if (currentName == "mirrorV") {
|
||||
XmlParser::getValueAsBool(currentNode, out.mMirrorV);
|
||||
} else if (currentName == "repeatU") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mTransform.mScaling.x);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.x);
|
||||
} else if (currentName == "repeatV") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mTransform.mScaling.y);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.y);
|
||||
} else if (currentName == "offsetU") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mTransform.mTranslation.x);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.x);
|
||||
} else if (currentName == "offsetV") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mTransform.mTranslation.y);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.y);
|
||||
} else if (currentName == "rotateUV") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mTransform.mRotation);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mTransform.mRotation);
|
||||
} else if (currentName == "blend_mode") {
|
||||
std::string v;
|
||||
XmlParser::getValueAsString(currentNode, v);
|
||||
|
@ -1198,14 +1198,14 @@ void ColladaParser::ReadSamplerProperties(XmlNode &node, Sampler &out) {
|
|||
// OKINO extensions
|
||||
// -------------------------------------------------------
|
||||
else if (currentName == "weighting") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mWeighting);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mWeighting);
|
||||
} else if (currentName == "mix_with_previous_layer") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mMixWithPrevious);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mMixWithPrevious);
|
||||
}
|
||||
// MAX3D extensions
|
||||
// -------------------------------------------------------
|
||||
else if (currentName == "amount") {
|
||||
XmlParser::getValueAsReal(currentNode, out.mWeighting);
|
||||
XmlParser::getValueAsFloat(currentNode, out.mWeighting);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1265,13 +1265,13 @@ void ColladaParser::ReadEffectColor(XmlNode &node, aiColor4D &pColor, Sampler &p
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Reads an effect entry containing a float
|
||||
void ColladaParser::ReadEffectFloat(XmlNode &node, ai_real &pReal) {
|
||||
pReal = 0.f;
|
||||
void ColladaParser::ReadEffectFloat(XmlNode &node, ai_real &pFloat) {
|
||||
pFloat = 0.f;
|
||||
XmlNode floatNode = node.child("float");
|
||||
if (floatNode.empty()) {
|
||||
return;
|
||||
}
|
||||
XmlParser::getValueAsReal(floatNode, pReal);
|
||||
XmlParser::getValueAsFloat(floatNode, pFloat);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
|
|
@ -181,9 +181,7 @@ FBXConverter::FBXConverter(aiScene *out, const Document &doc, bool removeEmptyBo
|
|||
if (out->mNumMeshes == 0) {
|
||||
out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
|
||||
} else {
|
||||
// Apply the FBX axis metadata unless requested not to
|
||||
if (!doc.Settings().ignoreUpDirection)
|
||||
correctRootTransform(mSceneOut);
|
||||
correctRootTransform(mSceneOut);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -312,8 +310,6 @@ void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node)
|
|||
|
||||
child->mParent = last_parent;
|
||||
last_parent = child.mNode;
|
||||
|
||||
new_abs_transform *= child->mTransformation;
|
||||
}
|
||||
|
||||
// attach geometry
|
||||
|
@ -336,8 +332,6 @@ void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node)
|
|||
|
||||
postnode->mParent = last_parent;
|
||||
last_parent = postnode.mNode;
|
||||
|
||||
new_abs_transform *= postnode->mTransformation;
|
||||
}
|
||||
} else {
|
||||
// free the nodes we allocated as we don't need them
|
||||
|
@ -363,12 +357,12 @@ void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node)
|
|||
if (nodes.empty()) {
|
||||
parent->mNumChildren = 0;
|
||||
parent->mChildren = nullptr;
|
||||
} else {
|
||||
parent->mChildren = new aiNode *[nodes.size()]();
|
||||
parent->mNumChildren = static_cast<unsigned int>(nodes.size());
|
||||
for (unsigned int i = 0; i < nodes.size(); ++i) {
|
||||
parent->mChildren[i] = nodes[i].mOwnership.release();
|
||||
}
|
||||
}
|
||||
|
||||
parent->mChildren = new aiNode *[nodes.size()]();
|
||||
parent->mNumChildren = static_cast<unsigned int>(nodes.size());
|
||||
for (unsigned int i = 0; i < nodes.size(); ++i) {
|
||||
parent->mChildren[i] = nodes[i].mOwnership.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2134,10 +2128,6 @@ void FBXConverter::SetTextureProperties(aiMaterial *out_mat, const TextureMap &_
|
|||
TrySetTextureProperties(out_mat, _textures, "Maya|emissionColor", aiTextureType_EMISSION_COLOR, mesh);
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|metalness", aiTextureType_METALNESS, mesh);
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|diffuseRoughness", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|base", aiTextureType_MAYA_BASE, mesh);
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|specular", aiTextureType_MAYA_SPECULAR, mesh);
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|specularColor", aiTextureType_MAYA_SPECULAR_COLOR, mesh);
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|specularRoughness", aiTextureType_MAYA_SPECULAR_ROUGHNESS, mesh);
|
||||
|
||||
// Maya stingray
|
||||
TrySetTextureProperties(out_mat, _textures, "Maya|TEX_color_map", aiTextureType_BASE_COLOR, mesh);
|
||||
|
|
|
@ -1217,8 +1217,10 @@ void FBXExporter::WriteObjects ()
|
|||
}
|
||||
|
||||
// colors, if any
|
||||
for (size_t ci = 0; ci < m->GetNumColorChannels(); ++ci) {
|
||||
FBX::Node vertexcolors("LayerElementColor", int32_t(ci));
|
||||
// TODO only one color channel currently
|
||||
const int32_t colorChannelIndex = 0;
|
||||
if (m->HasVertexColors(colorChannelIndex)) {
|
||||
FBX::Node vertexcolors("LayerElementColor", int32_t(colorChannelIndex));
|
||||
vertexcolors.Begin(outstream, binary, indent);
|
||||
vertexcolors.DumpProperties(outstream, binary, indent);
|
||||
vertexcolors.EndProperties(outstream, binary, indent);
|
||||
|
@ -1228,7 +1230,7 @@ void FBXExporter::WriteObjects ()
|
|||
"Version", int32_t(101), outstream, binary, indent
|
||||
);
|
||||
char layerName[8];
|
||||
snprintf(layerName, sizeof(layerName), "COLOR_%d", int32_t(ci));
|
||||
snprintf(layerName, sizeof(layerName), "COLOR_%d", colorChannelIndex);
|
||||
FBX::Node::WritePropertyNode(
|
||||
"Name", (const char*)layerName, outstream, binary, indent
|
||||
);
|
||||
|
@ -1245,7 +1247,7 @@ void FBXExporter::WriteObjects ()
|
|||
for (size_t fi = 0; fi < m->mNumFaces; ++fi) {
|
||||
const aiFace &f = m->mFaces[fi];
|
||||
for (size_t pvi = 0; pvi < f.mNumIndices; ++pvi) {
|
||||
const aiColor4D &c = m->mColors[ci][f.mIndices[pvi]];
|
||||
const aiColor4D &c = m->mColors[colorChannelIndex][f.mIndices[pvi]];
|
||||
color_data.push_back(c.r);
|
||||
color_data.push_back(c.g);
|
||||
color_data.push_back(c.b);
|
||||
|
@ -1352,14 +1354,11 @@ void FBXExporter::WriteObjects ()
|
|||
le.AddChild("Type", "LayerElementNormal");
|
||||
le.AddChild("TypedIndex", int32_t(0));
|
||||
layer.AddChild(le);
|
||||
|
||||
for (size_t ci = 0; ci < m->GetNumColorChannels(); ++ci) {
|
||||
le = FBX::Node("LayerElement");
|
||||
le.AddChild("Type", "LayerElementColor");
|
||||
le.AddChild("TypedIndex", int32_t(ci));
|
||||
layer.AddChild(le);
|
||||
}
|
||||
|
||||
// TODO only 1 color channel currently
|
||||
le = FBX::Node("LayerElement");
|
||||
le.AddChild("Type", "LayerElementColor");
|
||||
le.AddChild("TypedIndex", int32_t(0));
|
||||
layer.AddChild(le);
|
||||
le = FBX::Node("LayerElement");
|
||||
le.AddChild("Type", "LayerElementMaterial");
|
||||
le.AddChild("TypedIndex", int32_t(0));
|
||||
|
@ -2487,57 +2486,6 @@ const std::map<std::string,std::pair<std::string,char>> transform_types = {
|
|||
{"GeometricScalingInverse", {"GeometricScalingInverse", 'i'}}
|
||||
};
|
||||
|
||||
//add metadata to fbx property
|
||||
void add_meta(FBX::Node& fbx_node, const aiNode* node){
|
||||
if(node->mMetaData == nullptr) return;
|
||||
aiMetadata* meta = node->mMetaData;
|
||||
for (unsigned int i = 0; i < meta->mNumProperties; ++i) {
|
||||
aiString key = meta->mKeys[i];
|
||||
aiMetadataEntry* entry = &meta->mValues[i];
|
||||
switch (entry->mType) {
|
||||
case AI_BOOL:{
|
||||
bool val = *static_cast<bool *>(entry->mData);
|
||||
fbx_node.AddP70bool(key.C_Str(), val);
|
||||
break;
|
||||
}
|
||||
case AI_INT32:{
|
||||
int32_t val = *static_cast<int32_t *>(entry->mData);
|
||||
fbx_node.AddP70int(key.C_Str(), val);
|
||||
break;
|
||||
}
|
||||
case AI_UINT64:{
|
||||
//use string to add uint64
|
||||
uint64_t val = *static_cast<uint64_t *>(entry->mData);
|
||||
fbx_node.AddP70string(key.C_Str(), std::to_string(val).c_str());
|
||||
break;
|
||||
}
|
||||
case AI_FLOAT:{
|
||||
float val = *static_cast<float *>(entry->mData);
|
||||
fbx_node.AddP70double(key.C_Str(), val);
|
||||
break;
|
||||
}
|
||||
case AI_DOUBLE:{
|
||||
double val = *static_cast<double *>(entry->mData);
|
||||
fbx_node.AddP70double(key.C_Str(), val);
|
||||
break;
|
||||
}
|
||||
case AI_AISTRING:{
|
||||
aiString val = *static_cast<aiString *>(entry->mData);
|
||||
fbx_node.AddP70string(key.C_Str(), val.C_Str());
|
||||
break;
|
||||
}
|
||||
case AI_AIMETADATA: {
|
||||
//ignore
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// write a single model node to the stream
|
||||
void FBXExporter::WriteModelNode(
|
||||
StreamWriterLE& outstream,
|
||||
|
@ -2605,7 +2553,6 @@ void FBXExporter::WriteModelNode(
|
|||
}
|
||||
}
|
||||
}
|
||||
add_meta(p, node);
|
||||
m.AddChild(p);
|
||||
|
||||
// not sure what these are for,
|
||||
|
|
|
@ -156,9 +156,6 @@ struct ImportSettings {
|
|||
/** Set to true to perform a conversion from cm to meter after the import
|
||||
*/
|
||||
bool convertToMeters;
|
||||
|
||||
// Set to true to ignore the axis configuration in the file
|
||||
bool ignoreUpDirection = false;
|
||||
};
|
||||
|
||||
} // namespace FBX
|
||||
|
|
|
@ -117,7 +117,6 @@ void FBXImporter::SetupProperties(const Importer *pImp) {
|
|||
mSettings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false);
|
||||
mSettings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true);
|
||||
mSettings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false);
|
||||
mSettings.ignoreUpDirection = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION, false);
|
||||
mSettings.useSkeleton = pImp->GetPropertyBool(AI_CONFIG_FBX_USE_SKELETON_BONE_CONTAINER, false);
|
||||
}
|
||||
|
||||
|
|
|
@ -78,15 +78,7 @@ static constexpr aiImporterDesc desc = {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Recursive parsing of LWS files
|
||||
namespace {
|
||||
constexpr int MAX_DEPTH = 1000; // Define the maximum depth allowed
|
||||
}
|
||||
|
||||
void LWS::Element::Parse(const char *&buffer, const char *end, int depth) {
|
||||
if (depth > MAX_DEPTH) {
|
||||
throw std::runtime_error("Maximum recursion depth exceeded in LWS::Element::Parse");
|
||||
}
|
||||
|
||||
void LWS::Element::Parse(const char *&buffer, const char *end) {
|
||||
for (; SkipSpacesAndLineEnd(&buffer, end); SkipLine(&buffer, end)) {
|
||||
|
||||
// begin of a new element with children
|
||||
|
@ -129,7 +121,7 @@ void LWS::Element::Parse(const char *&buffer, const char *end, int depth) {
|
|||
|
||||
// parse more elements recursively
|
||||
if (sub) {
|
||||
children.back().Parse(buffer, end, depth + 1);
|
||||
children.back().Parse(buffer, end);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -76,7 +76,7 @@ public:
|
|||
std::list<Element> children;
|
||||
|
||||
//! Recursive parsing function
|
||||
void Parse(const char *&buffer, const char *end, int depth = 0);
|
||||
void Parse(const char *&buffer, const char *end);
|
||||
};
|
||||
|
||||
#define AI_LWS_MASK (0xffffffff >> 4u)
|
||||
|
|
|
@ -724,7 +724,6 @@ void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
std::vector<unsigned char> mBuffer2(fileSize);
|
||||
file->Read(&mBuffer2[0], 1, fileSize);
|
||||
mBuffer = &mBuffer2[0];
|
||||
const unsigned char* bufferEnd = mBuffer + fileSize;
|
||||
|
||||
pcHeader = (BE_NCONST MD3::Header *)mBuffer;
|
||||
|
||||
|
@ -750,15 +749,9 @@ void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
|
||||
// Navigate to the list of surfaces
|
||||
BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES);
|
||||
if ((const unsigned char*)pcSurfaces + sizeof(MD3::Surface) * pcHeader->NUM_SURFACES > bufferEnd) {
|
||||
throw DeadlyImportError("MD3 surface headers are outside the file");
|
||||
}
|
||||
|
||||
// Navigate to the list of tags
|
||||
BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS);
|
||||
if ((const unsigned char*)pcTags + sizeof(MD3::Tag) * pcHeader->NUM_TAGS > bufferEnd) {
|
||||
throw DeadlyImportError("MD3 tags are outside the file");
|
||||
}
|
||||
|
||||
// Allocate output storage
|
||||
pScene->mNumMeshes = pcHeader->NUM_SURFACES;
|
||||
|
@ -1033,10 +1026,6 @@ void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
|
||||
for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) {
|
||||
aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode();
|
||||
if ((const unsigned char*)pcTags + sizeof(MD3::Tag) > bufferEnd) {
|
||||
throw DeadlyImportError("MD3 tag is outside the file");
|
||||
}
|
||||
|
||||
nd->mName.Set((const char *)pcTags->NAME);
|
||||
nd->mParent = pScene->mRootNode;
|
||||
|
||||
|
|
|
@ -234,12 +234,8 @@ inline void AI_MD5_READ_TRIPLE(aiVector3D &vec, const char **sz, const char *buf
|
|||
AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber);
|
||||
if ('(' != **sz) {
|
||||
MD5Parser::ReportWarning("Unexpected token: ( was expected", linenumber);
|
||||
if (*sz == bufferEnd)
|
||||
return;
|
||||
++*sz;
|
||||
}
|
||||
if (*sz == bufferEnd)
|
||||
return;
|
||||
++*sz;
|
||||
AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber);
|
||||
*sz = fast_atoreal_move<float>(*sz, (float &)vec.x);
|
||||
|
@ -251,8 +247,6 @@ inline void AI_MD5_READ_TRIPLE(aiVector3D &vec, const char **sz, const char *buf
|
|||
if (')' != **sz) {
|
||||
MD5Parser::ReportWarning("Unexpected token: ) was expected", linenumber);
|
||||
}
|
||||
if (*sz == bufferEnd)
|
||||
return;
|
||||
++*sz;
|
||||
}
|
||||
|
||||
|
|
|
@ -63,8 +63,7 @@ struct HL1ImportSettings {
|
|||
read_bone_controllers(false),
|
||||
read_hitboxes(false),
|
||||
read_textures(false),
|
||||
read_misc_global_info(false),
|
||||
transform_coord_system(true) {
|
||||
read_misc_global_info(false) {
|
||||
}
|
||||
|
||||
bool read_animations;
|
||||
|
@ -77,7 +76,6 @@ struct HL1ImportSettings {
|
|||
bool read_hitboxes;
|
||||
bool read_textures;
|
||||
bool read_misc_global_info;
|
||||
bool transform_coord_system;
|
||||
};
|
||||
|
||||
} // namespace HalfLife
|
||||
|
|
|
@ -99,7 +99,7 @@ MDLImporter::MDLImporter() :
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
// Returns whether the class can handle the format of the given file.
|
||||
bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
|
||||
static constexpr uint32_t tokens[] = {
|
||||
static const uint32_t tokens[] = {
|
||||
AI_MDL_MAGIC_NUMBER_LE_HL2a,
|
||||
AI_MDL_MAGIC_NUMBER_LE_HL2b,
|
||||
AI_MDL_MAGIC_NUMBER_LE_GS7,
|
||||
|
@ -138,7 +138,6 @@ void MDLImporter::SetupProperties(const Importer *pImp) {
|
|||
mHL1ImportSettings.read_bone_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS, true);
|
||||
mHL1ImportSettings.read_hitboxes = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES, true);
|
||||
mHL1ImportSettings.read_misc_global_info = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO, true);
|
||||
mHL1ImportSettings.transform_coord_system = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_TRANSFORM_COORD_SYSTEM);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
@ -147,20 +146,6 @@ const aiImporterDesc *MDLImporter::GetInfo() const {
|
|||
return &desc;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
static void transformCoordinateSystem(const aiScene *pScene) {
|
||||
if (pScene == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
pScene->mRootNode->mTransformation = aiMatrix4x4(
|
||||
0.f, -1.f, 0.f, 0.f,
|
||||
0.f, 0.f, 1.f, 0.f,
|
||||
-1.f, 0.f, 0.f, 0.f,
|
||||
0.f, 0.f, 0.f, 1.f
|
||||
);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Imports the given file into the given scene structure.
|
||||
void MDLImporter::InternReadFile(const std::string &pFile,
|
||||
|
@ -261,16 +246,18 @@ void MDLImporter::InternReadFile(const std::string &pFile,
|
|||
". Magic word (", ai_str_toprintable((const char *)&iMagicWord, sizeof(iMagicWord)), ") is not known");
|
||||
}
|
||||
|
||||
if (is_half_life && mHL1ImportSettings.transform_coord_system) {
|
||||
if (is_half_life){
|
||||
// Now rotate the whole scene 90 degrees around the z and x axes to convert to internal coordinate system
|
||||
transformCoordinateSystem(pScene);
|
||||
} else {
|
||||
// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
|
||||
pScene->mRootNode->mTransformation = aiMatrix4x4(
|
||||
1.f, 0.f, 0.f, 0.f,
|
||||
0.f, 0.f, 1.f, 0.f,
|
||||
0.f, -1.f, 0.f, 0.f,
|
||||
0.f, 0.f, 0.f, 1.f);
|
||||
0.f, -1.f, 0.f, 0.f,
|
||||
0.f, 0.f, 1.f, 0.f,
|
||||
-1.f, 0.f, 0.f, 0.f,
|
||||
0.f, 0.f, 0.f, 1.f);
|
||||
}
|
||||
else {
|
||||
// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
|
||||
pScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
|
||||
0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
|
||||
}
|
||||
|
||||
DeleteBufferAndCleanup();
|
||||
|
|
|
@ -610,7 +610,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
|
|||
if (is_not_qnan(clrTexture.r)) {
|
||||
clrTemp.r *= clrTexture.a;
|
||||
}
|
||||
pcMatOut->AddProperty<float>(&clrTemp.r, 1, AI_MATKEY_OPACITY);
|
||||
pcMatOut->AddProperty<ai_real>(&clrTemp.r, 1, AI_MATKEY_OPACITY);
|
||||
|
||||
// read phong power
|
||||
int iShadingMode = (int)aiShadingMode_Gouraud;
|
||||
|
@ -730,12 +730,10 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
|
|||
// if an ASCII effect description (HLSL?) is contained in the file,
|
||||
// we can simply ignore it ...
|
||||
if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF) {
|
||||
VALIDATE_FILE_SIZE(szCurrent + sizeof(int32_t));
|
||||
int32_t iMe = 0;
|
||||
::memcpy(&iMe, szCurrent, sizeof(int32_t));
|
||||
AI_SWAP4(iMe);
|
||||
szCurrent += sizeof(char) * iMe + sizeof(int32_t);
|
||||
VALIDATE_FILE_SIZE(szCurrent);
|
||||
}
|
||||
*szCurrentOut = szCurrent;
|
||||
}
|
||||
|
|
|
@ -316,7 +316,7 @@ void OFFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
|
||||
aiMaterial *pcMat = new aiMaterial();
|
||||
|
||||
aiColor4D clr(0.6f, 0.6f, 0.6f, 1.0f);
|
||||
aiColor4D clr(ai_real(0.6), ai_real(0.6), ai_real(0.6), ai_real(1.0));
|
||||
pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
|
||||
pScene->mMaterials[0] = pcMat;
|
||||
|
||||
|
|
|
@ -199,12 +199,12 @@ struct Material {
|
|||
|
||||
//! Constructor
|
||||
Material() :
|
||||
diffuse(0.6f, 0.6f, 0.6f),
|
||||
diffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
|
||||
alpha(ai_real(1.0)),
|
||||
shineness(ai_real(0.0)),
|
||||
illumination_model(1),
|
||||
ior(ai_real(1.0)),
|
||||
transparent(1.0f, 1.0, 1.0),
|
||||
transparent(ai_real(1.0), ai_real(1.0), ai_real(1.0)),
|
||||
roughness(),
|
||||
metallic(),
|
||||
sheen(),
|
||||
|
|
|
@ -81,27 +81,6 @@ namespace {
|
|||
|
||||
return props[idx];
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
static bool isBigEndian(const char *szMe) {
|
||||
ai_assert(nullptr != szMe);
|
||||
|
||||
// binary_little_endian
|
||||
// binary_big_endian
|
||||
bool isBigEndian{ false };
|
||||
#if (defined AI_BUILD_BIG_ENDIAN)
|
||||
if ('l' == *szMe || 'L' == *szMe) {
|
||||
isBigEndian = true;
|
||||
}
|
||||
#else
|
||||
if ('b' == *szMe || 'B' == *szMe) {
|
||||
isBigEndian = true;
|
||||
}
|
||||
#endif // ! AI_BUILD_BIG_ENDIAN
|
||||
|
||||
return isBigEndian;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
@ -113,11 +92,6 @@ PLYImporter::PLYImporter() :
|
|||
// empty
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PLYImporter::~PLYImporter() {
|
||||
delete mGeneratedMesh;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Returns whether the class can handle the format of the given file.
|
||||
bool PLYImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
|
||||
|
@ -130,6 +104,26 @@ const aiImporterDesc *PLYImporter::GetInfo() const {
|
|||
return &desc;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
static bool isBigEndian(const char *szMe) {
|
||||
ai_assert(nullptr != szMe);
|
||||
|
||||
// binary_little_endian
|
||||
// binary_big_endian
|
||||
bool isBigEndian(false);
|
||||
#if (defined AI_BUILD_BIG_ENDIAN)
|
||||
if ('l' == *szMe || 'L' == *szMe) {
|
||||
isBigEndian = true;
|
||||
}
|
||||
#else
|
||||
if ('b' == *szMe || 'B' == *szMe) {
|
||||
isBigEndian = true;
|
||||
}
|
||||
#endif // ! AI_BUILD_BIG_ENDIAN
|
||||
|
||||
return isBigEndian;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Imports the given file into the given scene structure.
|
||||
void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
|
||||
|
@ -140,7 +134,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
}
|
||||
|
||||
// Get the file-size
|
||||
const size_t fileSize = fileStream->FileSize();
|
||||
const size_t fileSize(fileStream->FileSize());
|
||||
if (0 == fileSize) {
|
||||
throw DeadlyImportError("File ", pFile, " is empty.");
|
||||
}
|
||||
|
@ -186,7 +180,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
}
|
||||
} else if (!::strncmp(szMe, "binary_", 7)) {
|
||||
szMe += 7;
|
||||
const bool bIsBE = isBigEndian(szMe);
|
||||
const bool bIsBE(isBigEndian(szMe));
|
||||
|
||||
// skip the line, parse the rest of the header and build the DOM
|
||||
if (!PLY::DOM::ParseInstanceBinary(streamedBuffer, &sPlyDom, this, bIsBE)) {
|
||||
|
@ -247,9 +241,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
// fill the mesh list
|
||||
pScene->mNumMeshes = 1;
|
||||
pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
|
||||
pScene->mMeshes[0] = mGeneratedMesh;
|
||||
|
||||
// Move the mesh ownership into the scene instance
|
||||
pScene->mMeshes[0] = mGeneratedMesh;
|
||||
mGeneratedMesh = nullptr;
|
||||
|
||||
// generate a simple node structure
|
||||
|
@ -262,22 +254,20 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
}
|
||||
}
|
||||
|
||||
static constexpr ai_uint NotSet = 0xFFFFFFFF;
|
||||
|
||||
void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos) {
|
||||
ai_assert(nullptr != pcElement);
|
||||
ai_assert(nullptr != instElement);
|
||||
|
||||
ai_uint aiPositions[3] = { NotSet, NotSet, NotSet };
|
||||
ai_uint aiPositions[3] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
|
||||
PLY::EDataType aiTypes[3] = { EDT_Char, EDT_Char, EDT_Char };
|
||||
|
||||
ai_uint aiNormal[3] = { NotSet, NotSet, NotSet };
|
||||
ai_uint aiNormal[3] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
|
||||
PLY::EDataType aiNormalTypes[3] = { EDT_Char, EDT_Char, EDT_Char };
|
||||
|
||||
unsigned int aiColors[4] = { NotSet, NotSet, NotSet, NotSet };
|
||||
unsigned int aiColors[4] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
|
||||
PLY::EDataType aiColorsTypes[4] = { EDT_Char, EDT_Char, EDT_Char, EDT_Char };
|
||||
|
||||
unsigned int aiTexcoord[2] = { NotSet, NotSet };
|
||||
unsigned int aiTexcoord[2] = { 0xFFFFFFFF, 0xFFFFFFFF };
|
||||
PLY::EDataType aiTexcoordTypes[2] = { EDT_Char, EDT_Char };
|
||||
|
||||
// now check whether which normal components are available
|
||||
|
@ -347,17 +337,17 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
if (0 != cnt) {
|
||||
// Position
|
||||
aiVector3D vOut;
|
||||
if (NotSet != aiPositions[0]) {
|
||||
if (0xFFFFFFFF != aiPositions[0]) {
|
||||
vOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiPositions[0]).avList.front(), aiTypes[0]);
|
||||
}
|
||||
|
||||
if (NotSet != aiPositions[1]) {
|
||||
if (0xFFFFFFFF != aiPositions[1]) {
|
||||
vOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiPositions[1]).avList.front(), aiTypes[1]);
|
||||
}
|
||||
|
||||
if (NotSet != aiPositions[2]) {
|
||||
if (0xFFFFFFFF != aiPositions[2]) {
|
||||
vOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiPositions[2]).avList.front(), aiTypes[2]);
|
||||
}
|
||||
|
@ -365,19 +355,19 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
// Normals
|
||||
aiVector3D nOut;
|
||||
bool haveNormal = false;
|
||||
if (NotSet != aiNormal[0]) {
|
||||
if (0xFFFFFFFF != aiNormal[0]) {
|
||||
nOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiNormal[0]).avList.front(), aiNormalTypes[0]);
|
||||
haveNormal = true;
|
||||
}
|
||||
|
||||
if (NotSet != aiNormal[1]) {
|
||||
if (0xFFFFFFFF != aiNormal[1]) {
|
||||
nOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiNormal[1]).avList.front(), aiNormalTypes[1]);
|
||||
haveNormal = true;
|
||||
}
|
||||
|
||||
if (NotSet != aiNormal[2]) {
|
||||
if (0xFFFFFFFF != aiNormal[2]) {
|
||||
nOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiNormal[2]).avList.front(), aiNormalTypes[2]);
|
||||
haveNormal = true;
|
||||
|
@ -386,7 +376,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
// Colors
|
||||
aiColor4D cOut;
|
||||
bool haveColor = false;
|
||||
if (NotSet != aiColors[0]) {
|
||||
if (0xFFFFFFFF != aiColors[0]) {
|
||||
cOut.r = NormalizeColorValue(GetProperty(instElement->alProperties,
|
||||
aiColors[0])
|
||||
.avList.front(),
|
||||
|
@ -394,7 +384,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
haveColor = true;
|
||||
}
|
||||
|
||||
if (NotSet != aiColors[1]) {
|
||||
if (0xFFFFFFFF != aiColors[1]) {
|
||||
cOut.g = NormalizeColorValue(GetProperty(instElement->alProperties,
|
||||
aiColors[1])
|
||||
.avList.front(),
|
||||
|
@ -402,7 +392,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
haveColor = true;
|
||||
}
|
||||
|
||||
if (NotSet != aiColors[2]) {
|
||||
if (0xFFFFFFFF != aiColors[2]) {
|
||||
cOut.b = NormalizeColorValue(GetProperty(instElement->alProperties,
|
||||
aiColors[2])
|
||||
.avList.front(),
|
||||
|
@ -411,7 +401,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
}
|
||||
|
||||
// assume 1.0 for the alpha channel if it is not set
|
||||
if (NotSet == aiColors[3]) {
|
||||
if (0xFFFFFFFF == aiColors[3]) {
|
||||
cOut.a = 1.0;
|
||||
} else {
|
||||
cOut.a = NormalizeColorValue(GetProperty(instElement->alProperties,
|
||||
|
@ -426,13 +416,13 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
aiVector3D tOut;
|
||||
tOut.z = 0;
|
||||
bool haveTextureCoords = false;
|
||||
if (NotSet != aiTexcoord[0]) {
|
||||
if (0xFFFFFFFF != aiTexcoord[0]) {
|
||||
tOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiTexcoord[0]).avList.front(), aiTexcoordTypes[0]);
|
||||
haveTextureCoords = true;
|
||||
}
|
||||
|
||||
if (NotSet != aiTexcoord[1]) {
|
||||
if (0xFFFFFFFF != aiTexcoord[1]) {
|
||||
tOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
|
||||
GetProperty(instElement->alProperties, aiTexcoord[1]).avList.front(), aiTexcoordTypes[1]);
|
||||
haveTextureCoords = true;
|
||||
|
@ -448,9 +438,6 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
|
|||
mGeneratedMesh->mNumVertices = pcElement->NumOccur;
|
||||
mGeneratedMesh->mVertices = new aiVector3D[mGeneratedMesh->mNumVertices];
|
||||
}
|
||||
if (pos >= mGeneratedMesh->mNumVertices) {
|
||||
throw DeadlyImportError("Invalid .ply file: Too many vertices");
|
||||
}
|
||||
|
||||
mGeneratedMesh->mVertices[pos] = vOut;
|
||||
|
||||
|
@ -517,12 +504,16 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
|
|||
bool bOne = false;
|
||||
|
||||
// index of the vertex index list
|
||||
unsigned int iProperty = NotSet;
|
||||
unsigned int iProperty = 0xFFFFFFFF;
|
||||
PLY::EDataType eType = EDT_Char;
|
||||
bool bIsTriStrip = false;
|
||||
|
||||
// index of the material index property
|
||||
// unsigned int iMaterialIndex = 0xFFFFFFFF;
|
||||
// PLY::EDataType eType2 = EDT_Char;
|
||||
|
||||
// texture coordinates
|
||||
unsigned int iTextureCoord = NotSet;
|
||||
unsigned int iTextureCoord = 0xFFFFFFFF;
|
||||
PLY::EDataType eType3 = EDT_Char;
|
||||
|
||||
// face = unique number of vertex indices
|
||||
|
@ -581,7 +572,7 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
|
|||
|
||||
if (!bIsTriStrip) {
|
||||
// parse the list of vertex indices
|
||||
if (NotSet != iProperty) {
|
||||
if (0xFFFFFFFF != iProperty) {
|
||||
const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iProperty).avList.size();
|
||||
mGeneratedMesh->mFaces[pos].mNumIndices = iNum;
|
||||
mGeneratedMesh->mFaces[pos].mIndices = new unsigned int[iNum];
|
||||
|
@ -594,7 +585,15 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
|
|||
}
|
||||
}
|
||||
|
||||
if (NotSet != iTextureCoord) {
|
||||
// parse the material index
|
||||
// cannot be handled without processing the whole file first
|
||||
/*if (0xFFFFFFFF != iMaterialIndex)
|
||||
{
|
||||
mGeneratedMesh->mFaces[pos]. = PLY::PropertyInstance::ConvertTo<unsigned int>(
|
||||
GetProperty(instElement->alProperties, iMaterialIndex).avList.front(), eType2);
|
||||
}*/
|
||||
|
||||
if (0xFFFFFFFF != iTextureCoord) {
|
||||
const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iTextureCoord).avList.size();
|
||||
|
||||
// should be 6 coords
|
||||
|
@ -680,29 +679,41 @@ void PLYImporter::GetMaterialColor(const std::vector<PLY::PropertyInstance> &avL
|
|||
aiColor4D *clrOut) {
|
||||
ai_assert(nullptr != clrOut);
|
||||
|
||||
if (NotSet == aiPositions[0]) {
|
||||
if (0xFFFFFFFF == aiPositions[0])
|
||||
clrOut->r = 0.0f;
|
||||
} else {
|
||||
clrOut->r = NormalizeColorValue(GetProperty(avList, aiPositions[0]).avList.front(), aiTypes[0]);
|
||||
else {
|
||||
clrOut->r = NormalizeColorValue(GetProperty(avList,
|
||||
aiPositions[0])
|
||||
.avList.front(),
|
||||
aiTypes[0]);
|
||||
}
|
||||
|
||||
if (NotSet == aiPositions[1]) {
|
||||
if (0xFFFFFFFF == aiPositions[1])
|
||||
clrOut->g = 0.0f;
|
||||
} else {
|
||||
clrOut->g = NormalizeColorValue(GetProperty(avList, aiPositions[1]).avList.front(), aiTypes[1]);
|
||||
else {
|
||||
clrOut->g = NormalizeColorValue(GetProperty(avList,
|
||||
aiPositions[1])
|
||||
.avList.front(),
|
||||
aiTypes[1]);
|
||||
}
|
||||
|
||||
if (NotSet == aiPositions[2])
|
||||
if (0xFFFFFFFF == aiPositions[2])
|
||||
clrOut->b = 0.0f;
|
||||
else {
|
||||
clrOut->b = NormalizeColorValue(GetProperty(avList, aiPositions[2]).avList.front(), aiTypes[2]);
|
||||
clrOut->b = NormalizeColorValue(GetProperty(avList,
|
||||
aiPositions[2])
|
||||
.avList.front(),
|
||||
aiTypes[2]);
|
||||
}
|
||||
|
||||
// assume 1.0 for the alpha channel ifit is not set
|
||||
if (NotSet == aiPositions[3])
|
||||
if (0xFFFFFFFF == aiPositions[3])
|
||||
clrOut->a = 1.0f;
|
||||
else {
|
||||
clrOut->a = NormalizeColorValue(GetProperty(avList, aiPositions[3]).avList.front(), aiTypes[3]);
|
||||
clrOut->a = NormalizeColorValue(GetProperty(avList,
|
||||
aiPositions[3])
|
||||
.avList.front(),
|
||||
aiTypes[3]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -62,10 +62,10 @@ using namespace PLY;
|
|||
// ---------------------------------------------------------------------------
|
||||
/** Importer class to load the stanford PLY file format
|
||||
*/
|
||||
class PLYImporter final : public BaseImporter {
|
||||
class PLYImporter : public BaseImporter {
|
||||
public:
|
||||
PLYImporter();
|
||||
~PLYImporter() override;
|
||||
~PLYImporter() override = default;
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Returns whether the class can handle the format of the given file.
|
||||
|
@ -120,9 +120,13 @@ protected:
|
|||
PLY::PropertyInstance::ValueUnion val,
|
||||
PLY::EDataType eType);
|
||||
|
||||
private:
|
||||
/** Buffer to hold the loaded file */
|
||||
unsigned char *mBuffer;
|
||||
|
||||
/** Document object model representation extracted from the file */
|
||||
PLY::DOM *pcDOM;
|
||||
|
||||
/** Mesh generated by loader */
|
||||
aiMesh *mGeneratedMesh;
|
||||
};
|
||||
|
||||
|
|
|
@ -48,29 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <assimp/ByteSwapper.h>
|
||||
#include <assimp/fast_atof.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
|
||||
namespace Assimp {
|
||||
|
||||
std::string to_string(EElementSemantic e) {
|
||||
|
||||
switch (e) {
|
||||
case EEST_Vertex:
|
||||
return std::string{ "vertex" };
|
||||
case EEST_TriStrip:
|
||||
return std::string{ "tristrips" };
|
||||
case EEST_Edge:
|
||||
return std::string{ "edge" };
|
||||
case EEST_Material:
|
||||
return std::string{ "material" };
|
||||
case EEST_TextureFile:
|
||||
return std::string{ "TextureFile" };
|
||||
default:
|
||||
return std::string{ "invalid" };
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PLY::EDataType PLY::Property::ParseDataType(std::vector<char> &buffer) {
|
||||
ai_assert(!buffer.empty());
|
||||
|
@ -300,8 +281,6 @@ bool PLY::Element::ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<
|
|||
// if the exact semantic can't be determined, just store
|
||||
// the original string identifier
|
||||
pOut->szName = std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
|
||||
auto pos = pOut->szName.find_last_of(' ');
|
||||
pOut->szName.erase(pos, pOut->szName.size());
|
||||
}
|
||||
|
||||
if (!PLY::DOM::SkipSpaces(buffer))
|
||||
|
@ -434,7 +413,6 @@ bool PLY::DOM::SkipComments(std::vector<char> buffer) {
|
|||
bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) {
|
||||
ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseHeader() begin");
|
||||
|
||||
std::unordered_set<std::string> definedAlElements;
|
||||
// parse all elements
|
||||
while (!buffer.empty()) {
|
||||
// skip all comments
|
||||
|
@ -443,13 +421,6 @@ bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char>
|
|||
PLY::Element out;
|
||||
if (PLY::Element::ParseElement(streamBuffer, buffer, &out)) {
|
||||
// add the element to the list of elements
|
||||
|
||||
const auto propertyName = (out.szName.empty()) ? to_string(out.eSemantic) : out.szName;
|
||||
auto alreadyDefined = definedAlElements.find(propertyName);
|
||||
if (alreadyDefined != definedAlElements.end()) {
|
||||
throw DeadlyImportError("Property '" + propertyName + "' in header already defined ");
|
||||
}
|
||||
definedAlElements.insert(propertyName);
|
||||
alElements.push_back(out);
|
||||
} else if (TokenMatch(buffer, "end_header", 10)) {
|
||||
// we have reached the end of the header
|
||||
|
|
|
@ -400,12 +400,8 @@ void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) {
|
|||
}
|
||||
}
|
||||
|
||||
// nothing to do
|
||||
if (pcNode->mNumChildren == 0)
|
||||
return;
|
||||
|
||||
// now allocate the output array
|
||||
pcNode->mChildren = new aiNode *[pcNode->mNumChildren];
|
||||
pcNode->mChildren = new aiNode*[pcNode->mNumChildren];
|
||||
|
||||
// and fill all subnodes
|
||||
unsigned int qq( 0 );
|
||||
|
|
|
@ -181,7 +181,7 @@ void STLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
mBuffer = &buffer2[0];
|
||||
|
||||
// the default vertex color is light gray.
|
||||
mClrColorDefault.r = mClrColorDefault.g = mClrColorDefault.b = mClrColorDefault.a = 0.6f;
|
||||
mClrColorDefault.r = mClrColorDefault.g = mClrColorDefault.b = mClrColorDefault.a = (ai_real)0.6;
|
||||
|
||||
// allocate a single node
|
||||
mScene->mRootNode = new aiNode();
|
||||
|
@ -209,7 +209,7 @@ void STLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
}
|
||||
pcMat->AddProperty(&clrDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
|
||||
pcMat->AddProperty(&clrDiffuse, 1, AI_MATKEY_COLOR_SPECULAR);
|
||||
clrDiffuse = aiColor4D(0.05f, 0.05f, 0.05f, 1.0f);
|
||||
clrDiffuse = aiColor4D(ai_real(0.05), ai_real(0.05), ai_real(0.05), ai_real(1.0));
|
||||
pcMat->AddProperty(&clrDiffuse, 1, AI_MATKEY_COLOR_AMBIENT);
|
||||
|
||||
mScene->mNumMaterials = 1;
|
||||
|
|
|
@ -4,6 +4,7 @@ Open Asset Import Library (assimp)
|
|||
|
||||
Copyright (c) 2006-2024, assimp team
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
|
@ -36,9 +37,11 @@ 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.
|
||||
|
||||
@author: Richard Steffen, 2015
|
||||
----------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_EXPORT
|
||||
#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
|
||||
|
||||
|
|
|
@ -1,124 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.cpp
|
||||
* @brief Implementation of the USD importer class
|
||||
*/
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_USD_IMPORTER
|
||||
#include <memory>
|
||||
|
||||
// internal headers
|
||||
#include <assimp/ai_assert.h>
|
||||
#include <assimp/anim.h>
|
||||
#include <assimp/DefaultIOSystem.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <assimp/fast_atof.h>
|
||||
#include <assimp/Importer.hpp>
|
||||
#include <assimp/importerdesc.h>
|
||||
#include <assimp/IOStreamBuffer.h>
|
||||
#include <assimp/IOSystem.hpp>
|
||||
#include <assimp/scene.h>
|
||||
#include <assimp/StringUtils.h>
|
||||
#include <assimp/StreamReader.h>
|
||||
|
||||
#include "USDLoader.h"
|
||||
#include "USDLoaderUtil.h"
|
||||
#include "USDPreprocessor.h"
|
||||
|
||||
static constexpr aiImporterDesc desc = {
|
||||
"USD Object Importer",
|
||||
"",
|
||||
"",
|
||||
"https://en.wikipedia.org/wiki/Universal_Scene_Description/",
|
||||
aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
"usd usda usdc usdz"
|
||||
};
|
||||
|
||||
namespace Assimp {
|
||||
using namespace std;
|
||||
|
||||
// Constructor to be privately used by Importer
|
||||
USDImporter::USDImporter() :
|
||||
impl(USDImporterImplTinyusdz()) {
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
bool USDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool) const {
|
||||
// Based on token
|
||||
static const uint32_t usdcTokens[] = { AI_MAKE_MAGIC("PXR-USDC") };
|
||||
bool canRead = CheckMagicToken(pIOHandler, pFile, usdcTokens, AI_COUNT_OF(usdcTokens));
|
||||
if (canRead) {
|
||||
return canRead;
|
||||
}
|
||||
|
||||
// Based on extension
|
||||
// TODO: confirm OK to replace this w/SimpleExtensionCheck() below
|
||||
canRead = isUsd(pFile) || isUsda(pFile) || isUsdc(pFile) || isUsdz(pFile);
|
||||
if (canRead) {
|
||||
return canRead;
|
||||
}
|
||||
canRead = SimpleExtensionCheck(pFile, "usd", "usda", "usdc", "usdz");
|
||||
return canRead;
|
||||
}
|
||||
|
||||
const aiImporterDesc *USDImporter::GetInfo() const {
|
||||
return &desc;
|
||||
}
|
||||
|
||||
void USDImporter::InternReadFile(
|
||||
const std::string &pFile,
|
||||
aiScene *pScene,
|
||||
IOSystem *pIOHandler) {
|
||||
impl.InternReadFile(
|
||||
pFile,
|
||||
pScene,
|
||||
pIOHandler);
|
||||
}
|
||||
|
||||
} // namespace Assimp
|
||||
|
||||
#endif // !! ASSIMP_BUILD_NO_USD_IMPORTER
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.h
|
||||
* @brief Declaration of the USD importer class.
|
||||
*/
|
||||
#pragma once
|
||||
#ifndef AI_USDLOADER_H_INCLUDED
|
||||
#define AI_USDLOADER_H_INCLUDED
|
||||
|
||||
#include <assimp/BaseImporter.h>
|
||||
#include <assimp/types.h>
|
||||
#include <vector>
|
||||
#include <cstdint>
|
||||
|
||||
#include "USDLoaderImplTinyusdz.h"
|
||||
|
||||
namespace Assimp {
|
||||
class USDImporter : public BaseImporter {
|
||||
public:
|
||||
USDImporter();
|
||||
~USDImporter() override = default;
|
||||
|
||||
/// \brief Returns whether the class can handle the format of the given file.
|
||||
/// \remark See BaseImporter::CanRead() for details.
|
||||
bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
|
||||
|
||||
protected:
|
||||
//! \brief Appends the supported extension.
|
||||
const aiImporterDesc *GetInfo() const override;
|
||||
|
||||
void InternReadFile(
|
||||
const std::string &pFile,
|
||||
aiScene *pScene,
|
||||
IOSystem *pIOHandler) override;
|
||||
private:
|
||||
USDImporterImplTinyusdz impl;
|
||||
};
|
||||
|
||||
} // namespace Assimp
|
||||
#endif // AI_USDLOADER_H_INCLUDED
|
|
@ -1,749 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.cpp
|
||||
* @brief Implementation of the USD importer class
|
||||
*/
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_USD_IMPORTER
|
||||
#include <memory>
|
||||
#include <sstream>
|
||||
|
||||
// internal headers
|
||||
#include <assimp/ai_assert.h>
|
||||
#include <assimp/anim.h>
|
||||
#include <assimp/CreateAnimMesh.h>
|
||||
#include <assimp/DefaultIOSystem.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <assimp/fast_atof.h>
|
||||
#include <assimp/Importer.hpp>
|
||||
#include <assimp/importerdesc.h>
|
||||
#include <assimp/IOStreamBuffer.h>
|
||||
#include <assimp/IOSystem.hpp>
|
||||
#include <assimp/StringUtils.h>
|
||||
#include <assimp/StreamReader.h>
|
||||
|
||||
#include "io-util.hh" // namespace tinyusdz::io
|
||||
#include "tydra/scene-access.hh"
|
||||
#include "tydra/shader-network.hh"
|
||||
#include "USDLoaderImplTinyusdzHelper.h"
|
||||
#include "USDLoaderImplTinyusdz.h"
|
||||
#include "USDLoaderUtil.h"
|
||||
#include "USDPreprocessor.h"
|
||||
|
||||
#include "../../../contrib/tinyusdz/assimp_tinyusdz_logging.inc"
|
||||
|
||||
namespace {
|
||||
static constexpr char TAG[] = "tinyusdz loader";
|
||||
}
|
||||
|
||||
namespace Assimp {
|
||||
using namespace std;
|
||||
|
||||
void USDImporterImplTinyusdz::InternReadFile(
|
||||
const std::string &pFile,
|
||||
aiScene *pScene,
|
||||
IOSystem *) {
|
||||
// Grab filename for logging purposes
|
||||
size_t pos = pFile.find_last_of('/');
|
||||
string basePath = pFile.substr(0, pos);
|
||||
string nameWExt = pFile.substr(pos + 1);
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): model" << nameWExt;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
|
||||
bool ret{ false };
|
||||
tinyusdz::USDLoadOptions options;
|
||||
tinyusdz::Stage stage;
|
||||
std::string warn, err;
|
||||
bool is_usdz{ false };
|
||||
if (isUsdc(pFile)) {
|
||||
ret = LoadUSDCFromFile(pFile, &stage, &warn, &err, options);
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): LoadUSDCFromFile() result: " << ret;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
} else if (isUsda(pFile)) {
|
||||
ret = LoadUSDAFromFile(pFile, &stage, &warn, &err, options);
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): LoadUSDAFromFile() result: " << ret;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
} else if (isUsdz(pFile)) {
|
||||
ret = LoadUSDZFromFile(pFile, &stage, &warn, &err, options);
|
||||
is_usdz = true;
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): LoadUSDZFromFile() result: " << ret;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
} else if (isUsd(pFile)) {
|
||||
ret = LoadUSDFromFile(pFile, &stage, &warn, &err, options);
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): LoadUSDFromFile() result: " << ret;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
if (warn.empty() && err.empty()) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): load free of warnings/errors";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
} else {
|
||||
if (!warn.empty()) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): WARNING reported: " << warn;
|
||||
TINYUSDZLOGW(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
if (!err.empty()) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ERROR reported: " << err;
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
}
|
||||
if (!ret) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ERROR: load failed! ret: " << ret;
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
return;
|
||||
}
|
||||
tinyusdz::tydra::RenderScene render_scene;
|
||||
tinyusdz::tydra::RenderSceneConverter converter;
|
||||
tinyusdz::tydra::RenderSceneConverterEnv env(stage);
|
||||
std::string usd_basedir = tinyusdz::io::GetBaseDir(pFile);
|
||||
env.set_search_paths({ usd_basedir }); // {} needed to convert to vector of char
|
||||
|
||||
// NOTE: Pointer address of usdz_asset must be valid until the call of RenderSceneConverter::ConvertToRenderScene.
|
||||
tinyusdz::USDZAsset usdz_asset;
|
||||
if (is_usdz) {
|
||||
if (!tinyusdz::ReadUSDZAssetInfoFromFile(pFile, &usdz_asset, &warn, &err)) {
|
||||
if (!warn.empty()) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: WARNING reported: " << warn;
|
||||
TINYUSDZLOGW(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
if (!err.empty()) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: ERROR reported: " << err;
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: ERROR!";
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
} else {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: OK";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
|
||||
tinyusdz::AssetResolutionResolver arr;
|
||||
if (!tinyusdz::SetupUSDZAssetResolution(arr, &usdz_asset)) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): SetupUSDZAssetResolution: ERROR: load failed! ret: " << ret;
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
} else {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): SetupUSDZAssetResolution: OK";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
env.asset_resolver = arr;
|
||||
}
|
||||
}
|
||||
|
||||
ret = converter.ConvertToRenderScene(env, &render_scene);
|
||||
if (!ret) {
|
||||
ss.str("");
|
||||
ss << "InternReadFile(): ConvertToRenderScene() failed!";
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
// sanityCheckNodesRecursive(pScene->mRootNode);
|
||||
meshes(render_scene, pScene, nameWExt);
|
||||
materials(render_scene, pScene, nameWExt);
|
||||
textures(render_scene, pScene, nameWExt);
|
||||
textureImages(render_scene, pScene, nameWExt);
|
||||
buffers(render_scene, pScene, nameWExt);
|
||||
|
||||
std::map<size_t, tinyusdz::tydra::Node> meshNodes;
|
||||
setupNodes(render_scene, pScene, meshNodes, nameWExt);
|
||||
|
||||
setupBlendShapes(render_scene, pScene, nameWExt);
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::meshes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt) {
|
||||
stringstream ss;
|
||||
pScene->mNumMeshes = static_cast<unsigned int>(render_scene.meshes.size());
|
||||
pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
|
||||
ss.str("");
|
||||
ss << "meshes(): pScene->mNumMeshes: " << pScene->mNumMeshes;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
|
||||
// Export meshes
|
||||
for (size_t meshIdx = 0; meshIdx < pScene->mNumMeshes; meshIdx++) {
|
||||
pScene->mMeshes[meshIdx] = new aiMesh();
|
||||
pScene->mMeshes[meshIdx]->mName.Set(render_scene.meshes[meshIdx].prim_name);
|
||||
ss.str("");
|
||||
ss << " mesh[" << meshIdx << "]: " <<
|
||||
render_scene.meshes[meshIdx].joint_and_weights.jointIndices.size() << " jointIndices, " <<
|
||||
render_scene.meshes[meshIdx].joint_and_weights.jointWeights.size() << " jointWeights, elementSize: " <<
|
||||
render_scene.meshes[meshIdx].joint_and_weights.elementSize;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
ss.str("");
|
||||
ss << " skel_id: " << render_scene.meshes[meshIdx].skel_id;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
if (render_scene.meshes[meshIdx].material_id > -1) {
|
||||
pScene->mMeshes[meshIdx]->mMaterialIndex = render_scene.meshes[meshIdx].material_id;
|
||||
}
|
||||
verticesForMesh(render_scene, pScene, meshIdx, nameWExt);
|
||||
facesForMesh(render_scene, pScene, meshIdx, nameWExt);
|
||||
// Some models infer normals from faces, but others need them e.g.
|
||||
// - apple "toy car" canopy normals will be wrong
|
||||
// - human "untitled" model (tinyusdz issue #115) will be "splotchy"
|
||||
normalsForMesh(render_scene, pScene, meshIdx, nameWExt);
|
||||
materialsForMesh(render_scene, pScene, meshIdx, nameWExt);
|
||||
uvsForMesh(render_scene, pScene, meshIdx, nameWExt);
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::verticesForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(nameWExt);
|
||||
pScene->mMeshes[meshIdx]->mNumVertices = static_cast<unsigned int>(render_scene.meshes[meshIdx].points.size());
|
||||
pScene->mMeshes[meshIdx]->mVertices = new aiVector3D[pScene->mMeshes[meshIdx]->mNumVertices];
|
||||
for (size_t j = 0; j < pScene->mMeshes[meshIdx]->mNumVertices; ++j) {
|
||||
pScene->mMeshes[meshIdx]->mVertices[j].x = render_scene.meshes[meshIdx].points[j][0];
|
||||
pScene->mMeshes[meshIdx]->mVertices[j].y = render_scene.meshes[meshIdx].points[j][1];
|
||||
pScene->mMeshes[meshIdx]->mVertices[j].z = render_scene.meshes[meshIdx].points[j][2];
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::facesForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(nameWExt);
|
||||
pScene->mMeshes[meshIdx]->mNumFaces = static_cast<unsigned int>(render_scene.meshes[meshIdx].faceVertexCounts().size());
|
||||
pScene->mMeshes[meshIdx]->mFaces = new aiFace[pScene->mMeshes[meshIdx]->mNumFaces]();
|
||||
size_t faceVertIdxOffset = 0;
|
||||
for (size_t faceIdx = 0; faceIdx < pScene->mMeshes[meshIdx]->mNumFaces; ++faceIdx) {
|
||||
pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices = render_scene.meshes[meshIdx].faceVertexCounts()[faceIdx];
|
||||
pScene->mMeshes[meshIdx]->mFaces[faceIdx].mIndices = new unsigned int[pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices];
|
||||
for (size_t j = 0; j < pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices; ++j) {
|
||||
pScene->mMeshes[meshIdx]->mFaces[faceIdx].mIndices[j] =
|
||||
render_scene.meshes[meshIdx].faceVertexIndices()[j + faceVertIdxOffset];
|
||||
}
|
||||
faceVertIdxOffset += pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices;
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::normalsForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(nameWExt);
|
||||
pScene->mMeshes[meshIdx]->mNormals = new aiVector3D[pScene->mMeshes[meshIdx]->mNumVertices];
|
||||
const float *floatPtr = reinterpret_cast<const float *>(render_scene.meshes[meshIdx].normals.get_data().data());
|
||||
for (size_t vertIdx = 0, fpj = 0; vertIdx < pScene->mMeshes[meshIdx]->mNumVertices; ++vertIdx, fpj += 3) {
|
||||
pScene->mMeshes[meshIdx]->mNormals[vertIdx].x = floatPtr[fpj];
|
||||
pScene->mMeshes[meshIdx]->mNormals[vertIdx].y = floatPtr[fpj + 1];
|
||||
pScene->mMeshes[meshIdx]->mNormals[vertIdx].z = floatPtr[fpj + 2];
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::materialsForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(render_scene); UNUSED(pScene); UNUSED(meshIdx); UNUSED(nameWExt);
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::uvsForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(nameWExt);
|
||||
const size_t uvSlotsCount = render_scene.meshes[meshIdx].texcoords.size();
|
||||
if (uvSlotsCount < 1) {
|
||||
return;
|
||||
}
|
||||
pScene->mMeshes[meshIdx]->mTextureCoords[0] = new aiVector3D[pScene->mMeshes[meshIdx]->mNumVertices];
|
||||
pScene->mMeshes[meshIdx]->mNumUVComponents[0] = 2; // U and V stored in "x", "y" of aiVector3D.
|
||||
for (unsigned int uvSlotIdx = 0; uvSlotIdx < uvSlotsCount; ++uvSlotIdx) {
|
||||
const auto uvsForSlot = render_scene.meshes[meshIdx].texcoords.at(uvSlotIdx);
|
||||
if (uvsForSlot.get_data().size() == 0) {
|
||||
continue;
|
||||
}
|
||||
const float *floatPtr = reinterpret_cast<const float *>(uvsForSlot.get_data().data());
|
||||
for (size_t vertIdx = 0, fpj = 0; vertIdx < pScene->mMeshes[meshIdx]->mNumVertices; ++vertIdx, fpj += 2) {
|
||||
pScene->mMeshes[meshIdx]->mTextureCoords[uvSlotIdx][vertIdx].x = floatPtr[fpj];
|
||||
pScene->mMeshes[meshIdx]->mTextureCoords[uvSlotIdx][vertIdx].y = floatPtr[fpj + 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static aiColor3D *ownedColorPtrFor(const std::array<float, 3> &color) {
|
||||
aiColor3D *colorPtr = new aiColor3D();
|
||||
colorPtr->r = color[0];
|
||||
colorPtr->g = color[1];
|
||||
colorPtr->b = color[2];
|
||||
return colorPtr;
|
||||
}
|
||||
|
||||
static std::string nameForTextureWithId(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
const int targetId) {
|
||||
stringstream ss;
|
||||
std::string texName;
|
||||
for (const auto &image : render_scene.images) {
|
||||
if (image.buffer_id == targetId) {
|
||||
texName = image.asset_identifier;
|
||||
ss.str("");
|
||||
ss << "nameForTextureWithId(): found texture " << texName << " with target id " << targetId;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
break;
|
||||
}
|
||||
}
|
||||
ss.str("");
|
||||
ss << "nameForTextureWithId(): ERROR! Failed to find texture with target id " << targetId;
|
||||
TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
||||
return texName;
|
||||
}
|
||||
|
||||
static void assignTexture(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
const tinyusdz::tydra::RenderMaterial &material,
|
||||
aiMaterial *mat,
|
||||
const int textureId,
|
||||
const int aiTextureType) {
|
||||
UNUSED(material);
|
||||
std::string name = nameForTextureWithId(render_scene, textureId);
|
||||
aiString *texName = new aiString();
|
||||
texName->Set(name);
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "assignTexture(): name: " << name;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
// TODO: verify hard-coded '0' index is correct
|
||||
mat->AddProperty(texName, _AI_MATKEY_TEXTURE_BASE, aiTextureType, 0);
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::materials(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt) {
|
||||
const size_t numMaterials{render_scene.materials.size()};
|
||||
(void) numMaterials; // Ignore unused variable when -Werror enabled
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "materials(): model" << nameWExt << ", numMaterials: " << numMaterials;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
pScene->mNumMaterials = 0;
|
||||
if (render_scene.materials.empty()) {
|
||||
return;
|
||||
}
|
||||
pScene->mMaterials = new aiMaterial *[render_scene.materials.size()];
|
||||
for (const auto &material : render_scene.materials) {
|
||||
ss.str("");
|
||||
ss << " material[" << pScene->mNumMaterials << "]: name: |" << material.name << "|, disp name: |" << material.display_name << "|";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
aiMaterial *mat = new aiMaterial;
|
||||
|
||||
aiString *materialName = new aiString();
|
||||
materialName->Set(material.name);
|
||||
mat->AddProperty(materialName, AI_MATKEY_NAME);
|
||||
|
||||
mat->AddProperty(
|
||||
ownedColorPtrFor(material.surfaceShader.diffuseColor.value),
|
||||
1, AI_MATKEY_COLOR_DIFFUSE);
|
||||
mat->AddProperty(
|
||||
ownedColorPtrFor(material.surfaceShader.specularColor.value),
|
||||
1, AI_MATKEY_COLOR_SPECULAR);
|
||||
mat->AddProperty(
|
||||
ownedColorPtrFor(material.surfaceShader.emissiveColor.value),
|
||||
1, AI_MATKEY_COLOR_EMISSIVE);
|
||||
|
||||
ss.str("");
|
||||
if (material.surfaceShader.diffuseColor.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.diffuseColor.texture_id, aiTextureType_DIFFUSE);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: diff tex id " << material.surfaceShader.diffuseColor.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.specularColor.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.specularColor.texture_id, aiTextureType_SPECULAR);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: spec tex id " << material.surfaceShader.specularColor.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.normal.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.normal.texture_id, aiTextureType_NORMALS);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: normal tex id " << material.surfaceShader.normal.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.emissiveColor.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.emissiveColor.texture_id, aiTextureType_EMISSIVE);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: emissive tex id " << material.surfaceShader.emissiveColor.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.occlusion.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.occlusion.texture_id, aiTextureType_LIGHTMAP);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: lightmap (occlusion) tex id " << material.surfaceShader.occlusion.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.metallic.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.metallic.texture_id, aiTextureType_METALNESS);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: metallic tex id " << material.surfaceShader.metallic.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.roughness.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.roughness.texture_id, aiTextureType_DIFFUSE_ROUGHNESS);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: roughness tex id " << material.surfaceShader.roughness.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.clearcoat.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.clearcoat.texture_id, aiTextureType_CLEARCOAT);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: clearcoat tex id " << material.surfaceShader.clearcoat.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.opacity.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.opacity.texture_id, aiTextureType_OPACITY);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: opacity tex id " << material.surfaceShader.opacity.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.displacement.is_texture()) {
|
||||
assignTexture(render_scene, material, mat, material.surfaceShader.displacement.texture_id, aiTextureType_DISPLACEMENT);
|
||||
ss << " material[" << pScene->mNumMaterials << "]: displacement tex id " << material.surfaceShader.displacement.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.clearcoatRoughness.is_texture()) {
|
||||
ss << " material[" << pScene->mNumMaterials << "]: clearcoatRoughness tex id " << material.surfaceShader.clearcoatRoughness.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.opacityThreshold.is_texture()) {
|
||||
ss << " material[" << pScene->mNumMaterials << "]: opacityThreshold tex id " << material.surfaceShader.opacityThreshold.texture_id << "\n";
|
||||
}
|
||||
if (material.surfaceShader.ior.is_texture()) {
|
||||
ss << " material[" << pScene->mNumMaterials << "]: ior tex id " << material.surfaceShader.ior.texture_id << "\n";
|
||||
}
|
||||
if (!ss.str().empty()) {
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
|
||||
pScene->mMaterials[pScene->mNumMaterials] = mat;
|
||||
++pScene->mNumMaterials;
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::textures(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(pScene);
|
||||
const size_t numTextures{render_scene.textures.size()};
|
||||
UNUSED(numTextures); // Ignore unused variable when -Werror enabled
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "textures(): model" << nameWExt << ", numTextures: " << numTextures;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
size_t i{0};
|
||||
UNUSED(i);
|
||||
for (const auto &texture : render_scene.textures) {
|
||||
UNUSED(texture);
|
||||
ss.str("");
|
||||
ss << " texture[" << i << "]: id: " << texture.texture_image_id << ", disp name: |" << texture.display_name << "|, varname_uv: " <<
|
||||
texture.varname_uv << ", prim_name: |" << texture.prim_name << "|, abs_path: |" << texture.abs_path << "|";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* "owned" as in, used "new" to allocate and aiScene now responsible for "delete"
|
||||
*
|
||||
* @param render_scene renderScene object
|
||||
* @param image textureImage object
|
||||
* @param nameWExt filename w/ext (use to extract file type hint)
|
||||
* @return aiTexture ptr
|
||||
*/
|
||||
static aiTexture *ownedEmbeddedTextureFor(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
const tinyusdz::tydra::TextureImage &image,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(nameWExt);
|
||||
stringstream ss;
|
||||
aiTexture *tex = new aiTexture();
|
||||
size_t pos = image.asset_identifier.find_last_of('/');
|
||||
string embTexName{image.asset_identifier.substr(pos + 1)};
|
||||
tex->mFilename.Set(image.asset_identifier.c_str());
|
||||
tex->mHeight = image.height;
|
||||
// const size_t imageBytesCount{render_scene.buffers[image.buffer_id].data.size() / image.channels};
|
||||
tex->mWidth = image.width;
|
||||
if (tex->mHeight == 0) {
|
||||
pos = embTexName.find_last_of('.');
|
||||
strncpy(tex->achFormatHint, embTexName.substr(pos + 1).c_str(), 3);
|
||||
const size_t imageBytesCount{render_scene.buffers[image.buffer_id].data.size()};
|
||||
tex->pcData = (aiTexel *) new char[imageBytesCount];
|
||||
memcpy(tex->pcData, &render_scene.buffers[image.buffer_id].data[0], imageBytesCount);
|
||||
} else {
|
||||
string formatHint{"rgba8888"};
|
||||
strncpy(tex->achFormatHint, formatHint.c_str(), 8);
|
||||
const size_t imageTexelsCount{tex->mWidth * tex->mHeight};
|
||||
tex->pcData = (aiTexel *) new char[imageTexelsCount * image.channels];
|
||||
const float *floatPtr = reinterpret_cast<const float *>(&render_scene.buffers[image.buffer_id].data[0]);
|
||||
ss.str("");
|
||||
ss << "ownedEmbeddedTextureFor(): manual fill...";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
for (size_t i = 0, fpi = 0; i < imageTexelsCount; ++i, fpi += 4) {
|
||||
tex->pcData[i].b = static_cast<uint8_t>(floatPtr[fpi] * 255);
|
||||
tex->pcData[i].g = static_cast<uint8_t>(floatPtr[fpi + 1] * 255);
|
||||
tex->pcData[i].r = static_cast<uint8_t>(floatPtr[fpi + 2] * 255);
|
||||
tex->pcData[i].a = static_cast<uint8_t>(floatPtr[fpi + 3] * 255);
|
||||
}
|
||||
ss.str("");
|
||||
ss << "ownedEmbeddedTextureFor(): imageTexelsCount: " << imageTexelsCount << ", channels: " << image.channels;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
}
|
||||
return tex;
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::textureImages(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt) {
|
||||
stringstream ss;
|
||||
const size_t numTextureImages{render_scene.images.size()};
|
||||
UNUSED(numTextureImages); // Ignore unused variable when -Werror enabled
|
||||
ss.str("");
|
||||
ss << "textureImages(): model" << nameWExt << ", numTextureImages: " << numTextureImages;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
pScene->mTextures = nullptr; // Need to iterate over images before knowing if valid textures available
|
||||
pScene->mNumTextures = 0;
|
||||
for (const auto &image : render_scene.images) {
|
||||
ss.str("");
|
||||
ss << " image[" << pScene->mNumTextures << "]: |" << image.asset_identifier << "| w: " << image.width << ", h: " << image.height <<
|
||||
", channels: " << image.channels << ", miplevel: " << image.miplevel << ", buffer id: " << image.buffer_id << "\n" <<
|
||||
" buffers.size(): " << render_scene.buffers.size() << ", data empty? " << render_scene.buffers[image.buffer_id].data.empty();
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
if (image.buffer_id > -1 &&
|
||||
image.buffer_id < static_cast<long int>(render_scene.buffers.size()) &&
|
||||
!render_scene.buffers[image.buffer_id].data.empty()) {
|
||||
aiTexture *tex = ownedEmbeddedTextureFor(
|
||||
render_scene,
|
||||
image,
|
||||
nameWExt);
|
||||
if (pScene->mTextures == nullptr) {
|
||||
ss.str("");
|
||||
ss << " Init pScene->mTextures[" << render_scene.images.size() << "]";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
pScene->mTextures = new aiTexture *[render_scene.images.size()];
|
||||
}
|
||||
ss.str("");
|
||||
ss << " pScene->mTextures[" << pScene->mNumTextures << "] name: |" << tex->mFilename.C_Str() <<
|
||||
"|, w: " << tex->mWidth << ", h: " << tex->mHeight << ", hint: " << tex->achFormatHint;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
pScene->mTextures[pScene->mNumTextures++] = tex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::buffers(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt) {
|
||||
const size_t numBuffers{render_scene.buffers.size()};
|
||||
UNUSED(pScene); UNUSED(numBuffers); // Ignore unused variable when -Werror enabled
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "buffers(): model" << nameWExt << ", numBuffers: " << numBuffers;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
size_t i = 0;
|
||||
for (const auto &buffer : render_scene.buffers) {
|
||||
ss.str("");
|
||||
ss << " buffer[" << i << "]: count: " << buffer.data.size() << ", type: " << to_string(buffer.componentType);
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::setupNodes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
std::map<size_t, tinyusdz::tydra::Node> &meshNodes,
|
||||
const std::string &nameWExt) {
|
||||
stringstream ss;
|
||||
|
||||
pScene->mRootNode = nodes(render_scene, meshNodes, nameWExt);
|
||||
pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
|
||||
pScene->mRootNode->mMeshes = new unsigned int[pScene->mRootNode->mNumMeshes];
|
||||
ss.str("");
|
||||
ss << "setupNodes(): pScene->mNumMeshes: " << pScene->mNumMeshes;
|
||||
if (pScene->mRootNode != nullptr) {
|
||||
ss << ", mRootNode->mNumMeshes: " << pScene->mRootNode->mNumMeshes;
|
||||
}
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
|
||||
for (unsigned int meshIdx = 0; meshIdx < pScene->mNumMeshes; meshIdx++) {
|
||||
pScene->mRootNode->mMeshes[meshIdx] = meshIdx;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
aiNode *USDImporterImplTinyusdz::nodes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
std::map<size_t, tinyusdz::tydra::Node> &meshNodes,
|
||||
const std::string &nameWExt) {
|
||||
const size_t numNodes{render_scene.nodes.size()};
|
||||
(void) numNodes; // Ignore unused variable when -Werror enabled
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "nodes(): model" << nameWExt << ", numNodes: " << numNodes;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
return nodesRecursive(nullptr, render_scene.nodes[0], meshNodes);
|
||||
}
|
||||
|
||||
using Assimp::tinyusdzNodeTypeFor;
|
||||
using Assimp::tinyUsdzMat4ToAiMat4;
|
||||
using tinyusdz::tydra::NodeType;
|
||||
aiNode *USDImporterImplTinyusdz::nodesRecursive(
|
||||
aiNode *pNodeParent,
|
||||
const tinyusdz::tydra::Node &node,
|
||||
std::map<size_t, tinyusdz::tydra::Node> &meshNodes) {
|
||||
stringstream ss;
|
||||
aiNode *cNode = new aiNode();
|
||||
cNode->mParent = pNodeParent;
|
||||
cNode->mName.Set(node.prim_name);
|
||||
cNode->mTransformation = tinyUsdzMat4ToAiMat4(node.local_matrix.m);
|
||||
ss.str("");
|
||||
ss << "nodesRecursive(): node " << cNode->mName.C_Str() <<
|
||||
" type: |" << tinyusdzNodeTypeFor(node.nodeType) <<
|
||||
"|, disp " << node.display_name << ", abs " << node.abs_path;
|
||||
if (cNode->mParent != nullptr) {
|
||||
ss << " (parent " << cNode->mParent->mName.C_Str() << ")";
|
||||
}
|
||||
ss << " has " << node.children.size() << " children";
|
||||
if (node.id > -1) {
|
||||
ss << "\n node mesh id: " << node.id << " (node type: " << tinyusdzNodeTypeFor(node.nodeType) << ")";
|
||||
meshNodes[node.id] = node;
|
||||
}
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
if (!node.children.empty()) {
|
||||
cNode->mNumChildren = static_cast<unsigned int>(node.children.size());
|
||||
cNode->mChildren = new aiNode *[cNode->mNumChildren];
|
||||
}
|
||||
|
||||
size_t i{0};
|
||||
for (const auto &childNode: node.children) {
|
||||
cNode->mChildren[i] = nodesRecursive(cNode, childNode, meshNodes);
|
||||
++i;
|
||||
}
|
||||
return cNode;
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::sanityCheckNodesRecursive(
|
||||
aiNode *cNode) {
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "sanityCheckNodesRecursive(): node " << cNode->mName.C_Str();
|
||||
if (cNode->mParent != nullptr) {
|
||||
ss << " (parent " << cNode->mParent->mName.C_Str() << ")";
|
||||
}
|
||||
ss << " has " << cNode->mNumChildren << " children";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
for (size_t i = 0; i < cNode->mNumChildren; ++i) {
|
||||
sanityCheckNodesRecursive(cNode->mChildren[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::setupBlendShapes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt) {
|
||||
stringstream ss;
|
||||
ss.str("");
|
||||
ss << "setupBlendShapes(): iterating over " << pScene->mNumMeshes << " meshes for model" << nameWExt;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
for (size_t meshIdx = 0; meshIdx < pScene->mNumMeshes; meshIdx++) {
|
||||
blendShapesForMesh(render_scene, pScene, meshIdx, nameWExt);
|
||||
}
|
||||
}
|
||||
|
||||
void USDImporterImplTinyusdz::blendShapesForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt) {
|
||||
UNUSED(nameWExt);
|
||||
stringstream ss;
|
||||
const unsigned int numBlendShapeTargets{static_cast<unsigned int>(render_scene.meshes[meshIdx].targets.size())};
|
||||
UNUSED(numBlendShapeTargets); // Ignore unused variable when -Werror enabled
|
||||
ss.str("");
|
||||
ss << " blendShapesForMesh(): mesh[" << meshIdx << "], numBlendShapeTargets: " << numBlendShapeTargets;
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
if (numBlendShapeTargets > 0) {
|
||||
pScene->mMeshes[meshIdx]->mNumAnimMeshes = numBlendShapeTargets;
|
||||
pScene->mMeshes[meshIdx]->mAnimMeshes = new aiAnimMesh *[pScene->mMeshes[meshIdx]->mNumAnimMeshes];
|
||||
}
|
||||
auto mapIter = render_scene.meshes[meshIdx].targets.begin();
|
||||
size_t animMeshIdx{0};
|
||||
for (; mapIter != render_scene.meshes[meshIdx].targets.end(); ++mapIter) {
|
||||
const std::string name{mapIter->first};
|
||||
const tinyusdz::tydra::ShapeTarget shapeTarget{mapIter->second};
|
||||
pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx] = aiCreateAnimMesh(pScene->mMeshes[meshIdx]);
|
||||
ss.str("");
|
||||
ss << " mAnimMeshes[" << animMeshIdx << "]: mNumVertices: " << pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx]->mNumVertices <<
|
||||
", target: " << shapeTarget.pointIndices.size() << " pointIndices, " << shapeTarget.pointOffsets.size() <<
|
||||
" pointOffsets, " << shapeTarget.normalOffsets.size() << " normalOffsets";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
for (size_t iVert = 0; iVert < shapeTarget.pointOffsets.size(); ++iVert) {
|
||||
pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx]->mVertices[shapeTarget.pointIndices[iVert]] +=
|
||||
tinyUsdzScaleOrPosToAssimp(shapeTarget.pointOffsets[iVert]);
|
||||
}
|
||||
for (size_t iVert = 0; iVert < shapeTarget.normalOffsets.size(); ++iVert) {
|
||||
pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx]->mNormals[shapeTarget.pointIndices[iVert]] +=
|
||||
tinyUsdzScaleOrPosToAssimp(shapeTarget.normalOffsets[iVert]);
|
||||
}
|
||||
ss.str("");
|
||||
ss << " target[" << animMeshIdx << "]: name: " << name << ", prim_name: " <<
|
||||
shapeTarget.prim_name << ", abs_path: " << shapeTarget.abs_path <<
|
||||
", display_name: " << shapeTarget.display_name << ", " << shapeTarget.pointIndices.size() <<
|
||||
" pointIndices, " << shapeTarget.pointOffsets.size() << " pointOffsets, " <<
|
||||
shapeTarget.normalOffsets.size() << " normalOffsets, " << shapeTarget.inbetweens.size() <<
|
||||
" inbetweens";
|
||||
TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
||||
++animMeshIdx;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace Assimp
|
||||
|
||||
#endif // !! ASSIMP_BUILD_NO_USD_IMPORTER
|
|
@ -1,155 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.h
|
||||
* @brief Declaration of the USD importer class.
|
||||
*/
|
||||
#pragma once
|
||||
#ifndef AI_USDLOADER_IMPL_TINYUSDZ_H_INCLUDED
|
||||
#define AI_USDLOADER_IMPL_TINYUSDZ_H_INCLUDED
|
||||
|
||||
#include <assimp/BaseImporter.h>
|
||||
#include <assimp/scene.h>
|
||||
#include <assimp/types.h>
|
||||
#include <vector>
|
||||
#include <cstdint>
|
||||
#include "tinyusdz.hh"
|
||||
#include "tydra/render-data.hh"
|
||||
|
||||
namespace Assimp {
|
||||
class USDImporterImplTinyusdz {
|
||||
public:
|
||||
USDImporterImplTinyusdz() = default;
|
||||
~USDImporterImplTinyusdz() = default;
|
||||
|
||||
void InternReadFile(
|
||||
const std::string &pFile,
|
||||
aiScene *pScene,
|
||||
IOSystem *pIOHandler);
|
||||
|
||||
void meshes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void verticesForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void facesForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void normalsForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void materialsForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void uvsForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void materials(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void textures(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void textureImages(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void buffers(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void setupNodes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
std::map<size_t, tinyusdz::tydra::Node> &meshNodes,
|
||||
const std::string &nameWExt
|
||||
);
|
||||
|
||||
aiNode *nodes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
std::map<size_t, tinyusdz::tydra::Node> &meshNodes,
|
||||
const std::string &nameWExt);
|
||||
|
||||
aiNode *nodesRecursive(
|
||||
aiNode *pNodeParent,
|
||||
const tinyusdz::tydra::Node &node,
|
||||
std::map<size_t, tinyusdz::tydra::Node> &meshNodes);
|
||||
|
||||
void sanityCheckNodesRecursive(
|
||||
aiNode *pNode);
|
||||
|
||||
void setupBlendShapes(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
const std::string &nameWExt);
|
||||
|
||||
void blendShapesForMesh(
|
||||
const tinyusdz::tydra::RenderScene &render_scene,
|
||||
aiScene *pScene,
|
||||
size_t meshIdx,
|
||||
const std::string &nameWExt);
|
||||
};
|
||||
} // namespace Assimp
|
||||
#endif // AI_USDLOADER_IMPL_TINYUSDZ_H_INCLUDED
|
|
@ -1,151 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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_USD_IMPORTER
|
||||
#include "USDLoaderImplTinyusdzHelper.h"
|
||||
|
||||
#include "../../../contrib/tinyusdz/assimp_tinyusdz_logging.inc"
|
||||
|
||||
namespace {
|
||||
//const char *const TAG = "tinyusdz helper";
|
||||
}
|
||||
|
||||
using ChannelType = tinyusdz::tydra::AnimationChannel::ChannelType;
|
||||
std::string Assimp::tinyusdzAnimChannelTypeFor(ChannelType animChannel) {
|
||||
switch (animChannel) {
|
||||
case ChannelType::Transform: {
|
||||
return "Transform";
|
||||
}
|
||||
case ChannelType::Translation: {
|
||||
return "Translation";
|
||||
}
|
||||
case ChannelType::Rotation: {
|
||||
return "Rotation";
|
||||
}
|
||||
case ChannelType::Scale: {
|
||||
return "Scale";
|
||||
}
|
||||
case ChannelType::Weight: {
|
||||
return "Weight";
|
||||
}
|
||||
default:
|
||||
return "Invalid";
|
||||
}
|
||||
}
|
||||
|
||||
using tinyusdz::tydra::NodeType;
|
||||
std::string Assimp::tinyusdzNodeTypeFor(NodeType type) {
|
||||
switch (type) {
|
||||
case NodeType::Xform: {
|
||||
return "Xform";
|
||||
}
|
||||
case NodeType::Mesh: {
|
||||
return "Mesh";
|
||||
}
|
||||
case NodeType::Camera: {
|
||||
return "Camera";
|
||||
}
|
||||
case NodeType::Skeleton: {
|
||||
return "Skeleton";
|
||||
}
|
||||
case NodeType::PointLight: {
|
||||
return "PointLight";
|
||||
}
|
||||
case NodeType::DirectionalLight: {
|
||||
return "DirectionalLight";
|
||||
}
|
||||
case NodeType::EnvmapLight: {
|
||||
return "EnvmapLight";
|
||||
}
|
||||
default:
|
||||
return "Invalid";
|
||||
}
|
||||
}
|
||||
|
||||
aiMatrix4x4 Assimp::tinyUsdzMat4ToAiMat4(const double matIn[4][4]) {
|
||||
aiMatrix4x4 matOut;
|
||||
matOut.a1 = matIn[0][0];
|
||||
matOut.a2 = matIn[0][1];
|
||||
matOut.a3 = matIn[0][2];
|
||||
matOut.a4 = matIn[0][3];
|
||||
matOut.b1 = matIn[1][0];
|
||||
matOut.b2 = matIn[1][1];
|
||||
matOut.b3 = matIn[1][2];
|
||||
matOut.b4 = matIn[1][3];
|
||||
matOut.c1 = matIn[2][0];
|
||||
matOut.c2 = matIn[2][1];
|
||||
matOut.c3 = matIn[2][2];
|
||||
matOut.c4 = matIn[2][3];
|
||||
matOut.d1 = matIn[3][0];
|
||||
matOut.d2 = matIn[3][1];
|
||||
matOut.d3 = matIn[3][2];
|
||||
matOut.d4 = matIn[3][3];
|
||||
// matOut.a1 = matIn[0][0];
|
||||
// matOut.a2 = matIn[1][0];
|
||||
// matOut.a3 = matIn[2][0];
|
||||
// matOut.a4 = matIn[3][0];
|
||||
// matOut.b1 = matIn[0][1];
|
||||
// matOut.b2 = matIn[1][1];
|
||||
// matOut.b3 = matIn[2][1];
|
||||
// matOut.b4 = matIn[3][1];
|
||||
// matOut.c1 = matIn[0][2];
|
||||
// matOut.c2 = matIn[1][2];
|
||||
// matOut.c3 = matIn[2][2];
|
||||
// matOut.c4 = matIn[3][2];
|
||||
// matOut.d1 = matIn[0][3];
|
||||
// matOut.d2 = matIn[1][3];
|
||||
// matOut.d3 = matIn[2][3];
|
||||
// matOut.d4 = matIn[3][3];
|
||||
return matOut;
|
||||
}
|
||||
|
||||
aiVector3D Assimp::tinyUsdzScaleOrPosToAssimp(const std::array<float, 3> &scaleOrPosIn) {
|
||||
return aiVector3D(scaleOrPosIn[0], scaleOrPosIn[1], scaleOrPosIn[2]);
|
||||
}
|
||||
|
||||
aiQuaternion Assimp::tinyUsdzQuatToAiQuat(const std::array<float, 4> &quatIn) {
|
||||
// tinyusdz "quat" is x,y,z,w
|
||||
// aiQuaternion is w,x,y,z
|
||||
return aiQuaternion(
|
||||
quatIn[3], quatIn[0], quatIn[1], quatIn[2]);
|
||||
}
|
||||
|
||||
#endif // !! ASSIMP_BUILD_NO_USD_IMPORTER
|
|
@ -1,70 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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_USDLOADER_IMPL_TINYUSDZ_HELPER_H_INCLUDED
|
||||
#define AI_USDLOADER_IMPL_TINYUSDZ_HELPER_H_INCLUDED
|
||||
|
||||
#include <assimp/BaseImporter.h>
|
||||
#include <assimp/scene.h>
|
||||
#include <assimp/types.h>
|
||||
#include "tinyusdz.hh"
|
||||
#include "tydra/render-data.hh"
|
||||
|
||||
namespace Assimp {
|
||||
|
||||
std::string tinyusdzAnimChannelTypeFor(
|
||||
tinyusdz::tydra::AnimationChannel::ChannelType animChannel);
|
||||
std::string tinyusdzNodeTypeFor(tinyusdz::tydra::NodeType type);
|
||||
aiMatrix4x4 tinyUsdzMat4ToAiMat4(const double matIn[4][4]);
|
||||
|
||||
aiVector3D tinyUsdzScaleOrPosToAssimp(const std::array<float, 3> &scaleOrPosIn);
|
||||
|
||||
/**
|
||||
* Convert quaternion from tinyusdz "quat" to assimp "aiQuaternion" type
|
||||
*
|
||||
* @param quatIn tinyusdz float[4] in x,y,z,w order
|
||||
* @return assimp aiQuaternion converted from input
|
||||
*/
|
||||
aiQuaternion tinyUsdzQuatToAiQuat(const std::array<float, 4> &quatIn);
|
||||
|
||||
} // namespace Assimp
|
||||
#endif // AI_USDLOADER_IMPL_TINYUSDZ_HELPER_H_INCLUDED
|
|
@ -1,116 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.cpp
|
||||
* @brief Implementation of the USD importer class
|
||||
*/
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_USD_IMPORTER
|
||||
#include <memory>
|
||||
|
||||
// internal headers
|
||||
#include <assimp/ai_assert.h>
|
||||
#include <assimp/anim.h>
|
||||
#include <assimp/DefaultIOSystem.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <assimp/fast_atof.h>
|
||||
#include <assimp/Importer.hpp>
|
||||
#include <assimp/importerdesc.h>
|
||||
#include <assimp/IOStreamBuffer.h>
|
||||
#include <assimp/IOSystem.hpp>
|
||||
#include <assimp/scene.h>
|
||||
#include <assimp/StringUtils.h>
|
||||
#include <assimp/StreamReader.h>
|
||||
|
||||
#include "USDLoaderUtil.h"
|
||||
|
||||
namespace Assimp {
|
||||
using namespace std;
|
||||
bool isUsda(const std::string &pFile) {
|
||||
size_t pos = pFile.find_last_of('.');
|
||||
if (pos == string::npos) {
|
||||
return false;
|
||||
}
|
||||
string ext = pFile.substr(pos + 1);
|
||||
if (ext.size() != 4) {
|
||||
return false;
|
||||
}
|
||||
return (ext[0] == 'u' || ext[0] == 'U') && (ext[1] == 's' || ext[1] == 'S') && (ext[2] == 'd' || ext[2] == 'D') && (ext[3] == 'a' || ext[3] == 'A');
|
||||
}
|
||||
|
||||
bool isUsdc(const std::string &pFile) {
|
||||
size_t pos = pFile.find_last_of('.');
|
||||
if (pos == string::npos) {
|
||||
return false;
|
||||
}
|
||||
string ext = pFile.substr(pos + 1);
|
||||
if (ext.size() != 4) {
|
||||
return false;
|
||||
}
|
||||
return (ext[0] == 'u' || ext[0] == 'U') && (ext[1] == 's' || ext[1] == 'S') && (ext[2] == 'd' || ext[2] == 'D') && (ext[3] == 'c' || ext[3] == 'C');
|
||||
}
|
||||
|
||||
bool isUsdz(const std::string &pFile) {
|
||||
size_t pos = pFile.find_last_of('.');
|
||||
if (pos == string::npos) {
|
||||
return false;
|
||||
}
|
||||
string ext = pFile.substr(pos + 1);
|
||||
if (ext.size() != 4) {
|
||||
return false;
|
||||
}
|
||||
return (ext[0] == 'u' || ext[0] == 'U') && (ext[1] == 's' || ext[1] == 'S') && (ext[2] == 'd' || ext[2] == 'D') && (ext[3] == 'z' || ext[3] == 'Z');
|
||||
}
|
||||
|
||||
bool isUsd(const std::string &pFile) {
|
||||
size_t pos = pFile.find_last_of('.');
|
||||
if (pos == string::npos) {
|
||||
return false;
|
||||
}
|
||||
string ext = pFile.substr(pos + 1);
|
||||
if (ext.size() != 3) {
|
||||
return false;
|
||||
}
|
||||
return (ext[0] == 'u' || ext[0] == 'U') && (ext[1] == 's' || ext[1] == 'S') && (ext[2] == 'd' || ext[2] == 'D');
|
||||
}
|
||||
} // namespace Assimp
|
||||
|
||||
#endif // !! ASSIMP_BUILD_NO_USD_IMPORTER
|
|
@ -1,60 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.h
|
||||
* @brief Declaration of the USD importer class.
|
||||
*/
|
||||
#pragma once
|
||||
#ifndef AI_USDLOADER_UTIL_H_INCLUDED
|
||||
#define AI_USDLOADER_UTIL_H_INCLUDED
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace Assimp {
|
||||
|
||||
bool isUsda(const std::string &pFile);
|
||||
bool isUsdc(const std::string &pFile);
|
||||
bool isUsdz(const std::string &pFile);
|
||||
bool isUsd(const std::string &pFile);
|
||||
|
||||
} // namespace Assimp
|
||||
|
||||
#endif // AI_USDLOADER_UTIL_H_INCLUDED
|
|
@ -1,50 +0,0 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2024, 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 USDLoader.h
|
||||
* @brief Declaration of the USD importer class.
|
||||
*/
|
||||
#pragma once
|
||||
#ifndef AI_USDPREPROCESSOR_H_INCLUDED
|
||||
#define AI_USDPREPROCESSOR_H_INCLUDED
|
||||
|
||||
#define UNUSED(x) (void) x
|
||||
|
||||
#endif // AI_USDPREPROCESSOR_H_INCLUDED
|
|
@ -1036,10 +1036,10 @@ size_t Accessor::ExtractData(T *&outData, const std::vector<unsigned int> *remap
|
|||
outData = new T[usedCount];
|
||||
|
||||
if (remappingIndices != nullptr) {
|
||||
const unsigned int maxIndexCount = static_cast<unsigned int>(maxSize / stride);
|
||||
const unsigned int maxIndex = static_cast<unsigned int>(maxSize / stride - 1);
|
||||
for (size_t i = 0; i < usedCount; ++i) {
|
||||
size_t srcIdx = (*remappingIndices)[i];
|
||||
if (srcIdx >= maxIndexCount) {
|
||||
if (srcIdx > maxIndex) {
|
||||
throw DeadlyImportError("GLTF: index*stride ", (srcIdx * stride), " > maxSize ", maxSize, " in ", getContextForErrorMessages(id, name));
|
||||
}
|
||||
memcpy(outData + i, data + srcIdx * stride, elemSize);
|
||||
|
@ -1440,7 +1440,7 @@ inline void MaterialSheen::SetDefaults() {
|
|||
inline void MaterialVolume::SetDefaults() {
|
||||
//KHR_materials_volume properties
|
||||
thicknessFactor = 0.f;
|
||||
attenuationDistance = std::numeric_limits<float>::infinity();
|
||||
attenuationDistance = INFINITY;
|
||||
SetVector(attenuationColor, defaultAttenuationColor);
|
||||
}
|
||||
|
||||
|
|
|
@ -507,7 +507,7 @@ namespace glTF2 {
|
|||
|
||||
WriteTex(materialVolume, volume.thicknessTexture, "thicknessTexture", w.mAl);
|
||||
|
||||
if (volume.attenuationDistance != std::numeric_limits<float>::infinity()) {
|
||||
if (volume.attenuationDistance != INFINITY) {
|
||||
WriteFloat(materialVolume, volume.attenuationDistance, "attenuationDistance", w.mAl);
|
||||
}
|
||||
|
||||
|
@ -940,7 +940,7 @@ namespace glTF2 {
|
|||
if (outfile->Write(bodyBuffer->GetPointer(), 1, bodyBuffer->byteLength) != bodyBuffer->byteLength) {
|
||||
throw DeadlyExportError("Failed to write body data!");
|
||||
}
|
||||
if (curPaddingLength && outfile->Write(&padding, 1, curPaddingLength) != curPaddingLength) {
|
||||
if (curPaddingLength && outfile->Write(&padding, 1, paddingLength) != paddingLength) {
|
||||
throw DeadlyExportError("Failed to write body data padding!");
|
||||
}
|
||||
}
|
||||
|
|
|
@ -828,17 +828,6 @@ ADD_ASSIMP_IMPORTER( 3D
|
|||
AssetLib/Unreal/UnrealLoader.h
|
||||
)
|
||||
|
||||
ADD_ASSIMP_IMPORTER( USD
|
||||
AssetLib/USD/USDLoader.cpp
|
||||
AssetLib/USD/USDLoader.h
|
||||
AssetLib/USD/USDLoaderImplTinyusdz.cpp
|
||||
AssetLib/USD/USDLoaderImplTinyusdz.h
|
||||
AssetLib/USD/USDLoaderImplTinyusdzHelper.cpp
|
||||
AssetLib/USD/USDLoaderImplTinyusdzHelper.h
|
||||
AssetLib/USD/USDLoaderUtil.cpp
|
||||
AssetLib/USD/USDLoaderUtil.h
|
||||
)
|
||||
|
||||
ADD_ASSIMP_IMPORTER( X
|
||||
AssetLib/X/XFileHelper.h
|
||||
AssetLib/X/XFileImporter.cpp
|
||||
|
@ -932,128 +921,11 @@ SET( Extra_SRCS
|
|||
)
|
||||
SOURCE_GROUP( Extra FILES ${Extra_SRCS})
|
||||
|
||||
# USD/USDA/USDC/USDZ support
|
||||
# tinyusdz
|
||||
IF (ASSIMP_BUILD_USD_IMPORTER)
|
||||
if (ASSIMP_BUILD_USD_VERBOSE_LOGS)
|
||||
ADD_DEFINITIONS( -DASSIMP_USD_VERBOSE_LOGS)
|
||||
endif ()
|
||||
# Use CMAKE_CURRENT_SOURCE_DIR which provides assimp-local path (CMAKE_SOURCE_DIR is
|
||||
# relative to top-level/main project)
|
||||
set(Tinyusdz_BASE_ABSPATH "${CMAKE_CURRENT_SOURCE_DIR}/../contrib/tinyusdz")
|
||||
set(Tinyusdz_REPO_ABSPATH "${Tinyusdz_BASE_ABSPATH}/autoclone")
|
||||
|
||||
# Note: ALWAYS specify a git commit hash (or tag) instead of a branch name; using a branch
|
||||
# name can lead to non-deterministic (unpredictable) results since the code is potentially
|
||||
# in flux
|
||||
# "dev" branch, 9 Jul 2024
|
||||
set(TINYUSDZ_GIT_TAG "bd2a1edbbf69f352a6c40730114db9918c384848")
|
||||
message("****")
|
||||
message("\n\n**** Cloning tinyusdz repo, git tag ${TINYUSDZ_GIT_TAG}\n\n")
|
||||
|
||||
# Patch required to build arm32 on android
|
||||
set(TINYUSDZ_PATCH_CMD git apply ${Tinyusdz_BASE_ABSPATH}/patches/tinyusdz.patch)
|
||||
|
||||
# Note: CMake's "FetchContent" (which executes at configure time) is much better for this use case
|
||||
# than "ExternalProject" (which executes at build time); we just want to clone a repo and
|
||||
# block (wait) as long as necessary until cloning is complete, so we immediately have full
|
||||
# access to the cloned source files
|
||||
include(FetchContent)
|
||||
# Only want to clone once (on Android, using SOURCE_DIR will clone per-ABI (x86, x86_64 etc))
|
||||
set(FETCHCONTENT_BASE_DIR ${Tinyusdz_REPO_ABSPATH})
|
||||
set(FETCHCONTENT_QUIET on) # Turn off to troubleshoot repo clone problems
|
||||
set(FETCHCONTENT_UPDATES_DISCONNECTED on) # Prevent other ABIs from re-cloning/re-patching etc
|
||||
FetchContent_Declare(
|
||||
tinyusdz_repo
|
||||
GIT_REPOSITORY "https://github.com/lighttransport/tinyusdz"
|
||||
GIT_TAG ${TINYUSDZ_GIT_TAG}
|
||||
PATCH_COMMAND ${TINYUSDZ_PATCH_CMD}
|
||||
)
|
||||
FetchContent_MakeAvailable(tinyusdz_repo)
|
||||
message("**** Finished cloning tinyusdz repo")
|
||||
message("****")
|
||||
|
||||
set(Tinyusdz_SRC_ABSPATH "${Tinyusdz_REPO_ABSPATH}/tinyusdz_repo-src/src")
|
||||
set(Tinyusdz_SRCS
|
||||
${Tinyusdz_SRC_ABSPATH}/ascii-parser.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/ascii-parser-basetype.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/ascii-parser-timesamples.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/ascii-parser-timesamples-array.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/asset-resolution.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/composition.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/crate-format.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/crate-pprint.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/crate-reader.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/image-loader.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/image-util.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/image-writer.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/io-util.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/linear-algebra.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/path-util.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/pprinter.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/prim-composition.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/prim-reconstruct.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/prim-types.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/primvar.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/stage.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/str-util.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tiny-format.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tinyusdz.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/attribute-eval.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/attribute-eval-typed.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/attribute-eval-typed-animatable.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/attribute-eval-typed-animatable-fallback.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/attribute-eval-typed-fallback.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/facial.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/prim-apply.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/render-data.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/scene-access.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/tydra/shader-network.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usda-reader.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usda-writer.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdc-reader.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdc-writer.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdGeom.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdLux.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdMtlx.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdShade.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/usdSkel.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/value-pprint.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/value-types.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/xform.cc
|
||||
)
|
||||
|
||||
set(Tinyusdz_DEP_SOURCES
|
||||
${Tinyusdz_SRC_ABSPATH}/external/fpng.cpp
|
||||
#${Tinyusdz_SRC_ABSPATH}/external/staticstruct.cc
|
||||
#${Tinyusdz_SRC_ABSPATH}/external/string_id/database.cpp
|
||||
#${Tinyusdz_SRC_ABSPATH}/external/string_id/error.cpp
|
||||
#${Tinyusdz_SRC_ABSPATH}/external/string_id/string_id.cpp
|
||||
#${Tinyusdz_SRC_ABSPATH}/external/tinyxml2/tinyxml2.cpp
|
||||
${Tinyusdz_SRC_ABSPATH}/integerCoding.cpp
|
||||
${Tinyusdz_SRC_ABSPATH}/lz4-compression.cc
|
||||
${Tinyusdz_SRC_ABSPATH}/lz4/lz4.c
|
||||
)
|
||||
|
||||
set(tinyusdz_INCLUDE_DIRS "${Tinyusdz_SRC_ABSPATH}")
|
||||
INCLUDE_DIRECTORIES(${tinyusdz_INCLUDE_DIRS})
|
||||
SOURCE_GROUP( Contrib\\Tinyusdz
|
||||
FILES
|
||||
${Tinyusdz_SRCS}
|
||||
${Tinyusdz_DEP_SOURCES}
|
||||
)
|
||||
MESSAGE(STATUS "tinyusdz enabled")
|
||||
ELSE() # IF (ASSIMP_BUILD_USD_IMPORTER)
|
||||
set(Tinyusdz_SRCS "")
|
||||
set(Tinyusdz_DEP_SOURCES "")
|
||||
MESSAGE(STATUS "tinyusdz disabled")
|
||||
ENDIF() # IF (ASSIMP_BUILD_USD_IMPORTER)
|
||||
|
||||
# pugixml
|
||||
IF(ASSIMP_HUNTER_ENABLED)
|
||||
hunter_add_package(pugixml)
|
||||
find_package(pugixml CONFIG REQUIRED)
|
||||
ELSEIF(NOT TARGET pugixml::pugixml)
|
||||
ELSE()
|
||||
SET( Pugixml_SRCS
|
||||
../contrib/pugixml/src/pugiconfig.hpp
|
||||
../contrib/pugixml/src/pugixml.hpp
|
||||
|
@ -1299,8 +1171,6 @@ SET( assimp_src
|
|||
${openddl_parser_SRCS}
|
||||
${open3dgc_SRCS}
|
||||
${ziplib_SRCS}
|
||||
${Tinyusdz_SRCS}
|
||||
${Tinyusdz_DEP_SOURCES}
|
||||
${Pugixml_SRCS}
|
||||
${stb_SRCS}
|
||||
# Necessary to show the headers in the project when using the VC++ generator:
|
||||
|
@ -1334,7 +1204,7 @@ ADD_LIBRARY(assimp::assimp ALIAS assimp)
|
|||
IF (BUILD_SHARED_LIBS)
|
||||
TARGET_COMPILE_DEFINITIONS(assimp PRIVATE ASSIMP_BUILD_DLL_EXPORT)
|
||||
ELSE ()
|
||||
TARGET_COMPILE_DEFINITIONS(assimp PRIVATE OPENDDL_STATIC_LIBARY P2T_STATIC_EXPORTS)
|
||||
TARGET_COMPILE_DEFINITIONS(assimp PRIVATE OPENDDL_STATIC_LIBARY)
|
||||
ENDIF ()
|
||||
|
||||
TARGET_USE_COMMON_OUTPUT_DIRECTORY(assimp)
|
||||
|
@ -1396,7 +1266,6 @@ IF (ASSIMP_WARNINGS_AS_ERRORS)
|
|||
-Wno-unused-template
|
||||
-Wno-undefined-func-template
|
||||
-Wno-declaration-after-statement
|
||||
-Wno-deprecated-declarations
|
||||
)
|
||||
ELSE()
|
||||
TARGET_COMPILE_OPTIONS(assimp PRIVATE /W4 /WX)
|
||||
|
@ -1418,7 +1287,9 @@ TARGET_INCLUDE_DIRECTORIES ( assimp PUBLIC
|
|||
IF(ASSIMP_HUNTER_ENABLED)
|
||||
TARGET_LINK_LIBRARIES(assimp
|
||||
PUBLIC
|
||||
#polyclipping::polyclipping
|
||||
openddlparser::openddl_parser
|
||||
#poly2tri::poly2tri
|
||||
minizip::minizip
|
||||
ZLIB::zlib
|
||||
RapidJSON::rapidjson
|
||||
|
@ -1438,9 +1309,6 @@ ELSE()
|
|||
if (ASSIMP_BUILD_DRACO)
|
||||
target_link_libraries(assimp ${draco_LIBRARIES})
|
||||
endif()
|
||||
if(TARGET pugixml::pugixml)
|
||||
target_link_libraries(assimp pugixml::pugixml)
|
||||
endif()
|
||||
ENDIF()
|
||||
|
||||
if(ASSIMP_ANDROID_JNIIOSYSTEM)
|
||||
|
@ -1577,7 +1445,7 @@ if(MSVC AND ASSIMP_INSTALL_PDB)
|
|||
COMPILE_PDB_NAME_DEBUG assimp${LIBRARY_SUFFIX}${CMAKE_DEBUG_POSTFIX}
|
||||
)
|
||||
|
||||
IF(is_multi_config)
|
||||
IF(GENERATOR_IS_MULTI_CONFIG)
|
||||
install(FILES ${Assimp_BINARY_DIR}/code/Debug/assimp${LIBRARY_SUFFIX}${CMAKE_DEBUG_POSTFIX}.pdb
|
||||
DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
|
||||
CONFIGURATIONS Debug
|
||||
|
|
|
@ -359,25 +359,20 @@ void CallbackToLogRedirector(const char *msg, char *dt) {
|
|||
s->write(msg);
|
||||
}
|
||||
|
||||
static LogStream *DefaultStream = nullptr;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) {
|
||||
aiLogStream sout;
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
if (DefaultStream == nullptr) {
|
||||
DefaultStream = LogStream::createDefaultStream(pStream, file);
|
||||
}
|
||||
|
||||
if (!DefaultStream) {
|
||||
LogStream *stream = LogStream::createDefaultStream(pStream, file);
|
||||
if (!stream) {
|
||||
sout.callback = nullptr;
|
||||
sout.user = nullptr;
|
||||
} else {
|
||||
sout.callback = &CallbackToLogRedirector;
|
||||
sout.user = (char *)DefaultStream;
|
||||
sout.user = (char *)stream;
|
||||
}
|
||||
gPredefinedStreams.push_back(DefaultStream);
|
||||
gPredefinedStreams.push_back(stream);
|
||||
ASSIMP_END_EXCEPTION_REGION(aiLogStream);
|
||||
return sout;
|
||||
}
|
||||
|
@ -517,11 +512,6 @@ void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn,
|
|||
ASSIMP_END_EXCEPTION_REGION(void);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API const C_STRUCT aiTexture *aiGetEmbeddedTexture(const C_STRUCT aiScene *pIn, const char *filename) {
|
||||
return pIn->GetEmbeddedTexture(filename);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) {
|
||||
return reinterpret_cast<aiPropertyStore *>(new PropertyMap());
|
||||
|
@ -753,14 +743,14 @@ ASSIMP_API void aiVector2DivideByVector(
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiVector2Length(
|
||||
ASSIMP_API float aiVector2Length(
|
||||
const C_STRUCT aiVector2D *v) {
|
||||
ai_assert(nullptr != v);
|
||||
return v->Length();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiVector2SquareLength(
|
||||
ASSIMP_API float aiVector2SquareLength(
|
||||
const C_STRUCT aiVector2D *v) {
|
||||
ai_assert(nullptr != v);
|
||||
return v->SquareLength();
|
||||
|
@ -774,7 +764,7 @@ ASSIMP_API void aiVector2Negate(
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiVector2DotProduct(
|
||||
ASSIMP_API float aiVector2DotProduct(
|
||||
const C_STRUCT aiVector2D *a,
|
||||
const C_STRUCT aiVector2D *b) {
|
||||
ai_assert(nullptr != a);
|
||||
|
@ -869,14 +859,14 @@ ASSIMP_API void aiVector3DivideByVector(
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiVector3Length(
|
||||
ASSIMP_API float aiVector3Length(
|
||||
const C_STRUCT aiVector3D *v) {
|
||||
ai_assert(nullptr != v);
|
||||
return v->Length();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiVector3SquareLength(
|
||||
ASSIMP_API float aiVector3SquareLength(
|
||||
const C_STRUCT aiVector3D *v) {
|
||||
ai_assert(nullptr != v);
|
||||
return v->SquareLength();
|
||||
|
@ -890,7 +880,7 @@ ASSIMP_API void aiVector3Negate(
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiVector3DotProduct(
|
||||
ASSIMP_API float aiVector3DotProduct(
|
||||
const C_STRUCT aiVector3D *a,
|
||||
const C_STRUCT aiVector3D *b) {
|
||||
ai_assert(nullptr != a);
|
||||
|
@ -976,7 +966,7 @@ ASSIMP_API void aiMatrix3Inverse(C_STRUCT aiMatrix3x3 *mat) {
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiMatrix3Determinant(const C_STRUCT aiMatrix3x3 *mat) {
|
||||
ASSIMP_API float aiMatrix3Determinant(const C_STRUCT aiMatrix3x3 *mat) {
|
||||
ai_assert(nullptr != mat);
|
||||
return mat->Determinant();
|
||||
}
|
||||
|
@ -1076,7 +1066,7 @@ ASSIMP_API void aiMatrix4Inverse(C_STRUCT aiMatrix4x4 *mat) {
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ASSIMP_API ai_real aiMatrix4Determinant(const C_STRUCT aiMatrix4x4 *mat) {
|
||||
ASSIMP_API float aiMatrix4Determinant(const C_STRUCT aiMatrix4x4 *mat) {
|
||||
ai_assert(nullptr != mat);
|
||||
return mat->Determinant();
|
||||
}
|
||||
|
@ -1278,6 +1268,7 @@ ASSIMP_API void aiQuaternionInterpolate(
|
|||
aiQuaternion::Interpolate(*dst, *start, *end, factor);
|
||||
}
|
||||
|
||||
|
||||
// stb_image is a lightweight image loader. It is shared by:
|
||||
// - M3D import
|
||||
// - PBRT export
|
||||
|
@ -1288,21 +1279,21 @@ ASSIMP_API void aiQuaternionInterpolate(
|
|||
#define ASSIMP_HAS_M3D ((!ASSIMP_BUILD_NO_EXPORT && !ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER)
|
||||
|
||||
#ifndef STB_USE_HUNTER
|
||||
#if ASSIMP_HAS_PBRT_EXPORT
|
||||
#define ASSIMP_NEEDS_STB_IMAGE 1
|
||||
#elif ASSIMP_HAS_M3D
|
||||
#define ASSIMP_NEEDS_STB_IMAGE 1
|
||||
#define STBI_ONLY_PNG
|
||||
#endif
|
||||
# if ASSIMP_HAS_PBRT_EXPORT
|
||||
# define ASSIMP_NEEDS_STB_IMAGE 1
|
||||
# elif ASSIMP_HAS_M3D
|
||||
# define ASSIMP_NEEDS_STB_IMAGE 1
|
||||
# define STBI_ONLY_PNG
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// Ensure all symbols are linked correctly
|
||||
#if ASSIMP_NEEDS_STB_IMAGE
|
||||
// Share stb_image's PNG loader with other importers/exporters instead of bringing our own copy.
|
||||
#define STBI_ONLY_PNG
|
||||
#ifdef ASSIMP_USE_STB_IMAGE_STATIC
|
||||
#define STB_IMAGE_STATIC
|
||||
#endif
|
||||
#define STB_IMAGE_IMPLEMENTATION
|
||||
#include "Common/StbCommon.h"
|
||||
// Share stb_image's PNG loader with other importers/exporters instead of bringing our own copy.
|
||||
# define STBI_ONLY_PNG
|
||||
# ifdef ASSIMP_USE_STB_IMAGE_STATIC
|
||||
# define STB_IMAGE_STATIC
|
||||
# endif
|
||||
# define STB_IMAGE_IMPLEMENTATION
|
||||
# include "Common/StbCommon.h"
|
||||
#endif
|
||||
|
|
|
@ -250,10 +250,9 @@ void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
|
|||
/*static*/ bool BaseImporter::SimpleExtensionCheck(const std::string &pFile,
|
||||
const char *ext0,
|
||||
const char *ext1,
|
||||
const char *ext2,
|
||||
const char *ext3) {
|
||||
const char *ext2) {
|
||||
std::set<std::string> extensions;
|
||||
for (const char* ext : {ext0, ext1, ext2, ext3}) {
|
||||
for (const char* ext : {ext0, ext1, ext2}) {
|
||||
if (ext == nullptr) continue;
|
||||
extensions.emplace(ext);
|
||||
}
|
||||
|
|
|
@ -93,10 +93,6 @@ static std::string WideToUtf8(const wchar_t *in) {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
// Tests for the existence of a file at the given path.
|
||||
bool DefaultIOSystem::Exists(const char *pFile) const {
|
||||
if (pFile == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
struct __stat64 filestat;
|
||||
if (_wstat64(Utf8ToWide(pFile).c_str(), &filestat) != 0) {
|
||||
|
|
|
@ -848,7 +848,11 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
|
|||
break;
|
||||
}
|
||||
#ifdef ASSIMP_BUILD_DEBUG
|
||||
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
||||
|
||||
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
||||
continue;
|
||||
#endif // no validation
|
||||
|
||||
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
|
||||
if (pimpl->bExtraVerbose) {
|
||||
ASSIMP_LOG_DEBUG("Verbose Import: re-validating data structures");
|
||||
|
@ -860,7 +864,6 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
#endif // no validation
|
||||
#endif // ! DEBUG
|
||||
}
|
||||
pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()),
|
||||
|
@ -936,7 +939,6 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
|
|||
profiler->EndRegion( "postprocess" );
|
||||
}
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
||||
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
|
||||
if ( pimpl->bExtraVerbose || requestValidation ) {
|
||||
ASSIMP_LOG_DEBUG( "Verbose Import: revalidating data structures" );
|
||||
|
@ -947,7 +949,6 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
|
|||
ASSIMP_LOG_ERROR( "Verbose Import: failed to revalidate data structures" );
|
||||
}
|
||||
}
|
||||
#endif // no validation
|
||||
|
||||
// clear any data allocated by post-process steps
|
||||
pimpl->mPPShared->Clean();
|
||||
|
|
|
@ -55,9 +55,6 @@ corresponding preprocessor flag to selectively disable formats.
|
|||
// Importers
|
||||
// (include_new_importers_here)
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#if !defined(ASSIMP_BUILD_NO_USD_IMPORTER)
|
||||
#include "AssetLib/USD/USDLoader.h"
|
||||
#endif
|
||||
#ifndef ASSIMP_BUILD_NO_X_IMPORTER
|
||||
#include "AssetLib/X/XFileImporter.h"
|
||||
#endif
|
||||
|
@ -233,9 +230,6 @@ void GetImporterInstanceList(std::vector<BaseImporter *> &out) {
|
|||
// (register_new_importers_here)
|
||||
// ----------------------------------------------------------------------------
|
||||
out.reserve(64);
|
||||
#if !defined(ASSIMP_BUILD_NO_USD_IMPORTER)
|
||||
out.push_back(new USDImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_X_IMPORTER)
|
||||
out.push_back(new XFileImporter());
|
||||
#endif
|
||||
|
|
|
@ -63,7 +63,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <assimp/scene.h>
|
||||
#include <stdio.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <unordered_set>
|
||||
|
||||
namespace Assimp {
|
||||
|
||||
|
@ -253,14 +252,6 @@ void SceneCombiner::AttachToGraph(aiScene *master, std::vector<NodeAttachmentInf
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<AttachmentInfo> &srcList, unsigned int flags) {
|
||||
if (nullptr == _dest) {
|
||||
std::unordered_set<aiScene *> uniqueScenes;
|
||||
uniqueScenes.insert(master);
|
||||
for (const auto &item : srcList) {
|
||||
uniqueScenes.insert(item.scene);
|
||||
}
|
||||
for (const auto &item : uniqueScenes) {
|
||||
delete item;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -268,7 +259,6 @@ void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<At
|
|||
if (srcList.empty()) {
|
||||
if (*_dest) {
|
||||
SceneCombiner::CopySceneFlat(_dest, master);
|
||||
delete master;
|
||||
} else
|
||||
*_dest = master;
|
||||
return;
|
||||
|
@ -1067,7 +1057,7 @@ void SceneCombiner::CopyScene(aiScene **_dest, const aiScene *src, bool allocate
|
|||
dest->mFlags = src->mFlags;
|
||||
|
||||
// source private data might be nullptr if the scene is user-allocated (i.e. for use with the export API)
|
||||
if (src->mPrivate != nullptr) {
|
||||
if (dest->mPrivate != nullptr) {
|
||||
ScenePriv(dest)->mPPStepsApplied = ScenePriv(src) ? ScenePriv(src)->mPPStepsApplied : 0;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -71,6 +71,10 @@ SpatialSort::SpatialSort() :
|
|||
mPlaneNormal.Normalize();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Destructor
|
||||
SpatialSort::~SpatialSort() = default;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void SpatialSort::Fill(const aiVector3D *pPositions, unsigned int pNumPositions,
|
||||
unsigned int pElementOffset,
|
||||
|
|
|
@ -174,95 +174,6 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial *pMat,
|
|||
return AI_SUCCESS;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Get an array of floating-point values from the material.
|
||||
aiReturn aiGetMaterialDoubleArray(const aiMaterial *pMat,
|
||||
const char *pKey,
|
||||
unsigned int type,
|
||||
unsigned int index,
|
||||
double *pOut,
|
||||
unsigned int *pMax) {
|
||||
ai_assert(pOut != nullptr);
|
||||
ai_assert(pMat != nullptr);
|
||||
|
||||
const aiMaterialProperty *prop;
|
||||
aiGetMaterialProperty(pMat, pKey, type, index, (const aiMaterialProperty **)&prop);
|
||||
if (nullptr == prop) {
|
||||
return AI_FAILURE;
|
||||
}
|
||||
|
||||
// data is given in floats, convert to ai_real
|
||||
unsigned int iWrite = 0;
|
||||
if (aiPTI_Float == prop->mType || aiPTI_Buffer == prop->mType) {
|
||||
iWrite = prop->mDataLength / sizeof(float);
|
||||
if (pMax) {
|
||||
iWrite = std::min(*pMax, iWrite);
|
||||
;
|
||||
}
|
||||
|
||||
for (unsigned int a = 0; a < iWrite; ++a) {
|
||||
pOut[a] = static_cast<ai_real>(reinterpret_cast<float *>(prop->mData)[a]);
|
||||
}
|
||||
|
||||
if (pMax) {
|
||||
*pMax = iWrite;
|
||||
}
|
||||
}
|
||||
// data is given in doubles, convert to float
|
||||
else if (aiPTI_Double == prop->mType) {
|
||||
iWrite = prop->mDataLength / sizeof(double);
|
||||
if (pMax) {
|
||||
iWrite = std::min(*pMax, iWrite);
|
||||
;
|
||||
}
|
||||
for (unsigned int a = 0; a < iWrite; ++a) {
|
||||
pOut[a] = static_cast<ai_real>(reinterpret_cast<double *>(prop->mData)[a]);
|
||||
}
|
||||
if (pMax) {
|
||||
*pMax = iWrite;
|
||||
}
|
||||
}
|
||||
// data is given in ints, convert to float
|
||||
else if (aiPTI_Integer == prop->mType) {
|
||||
iWrite = prop->mDataLength / sizeof(int32_t);
|
||||
if (pMax) {
|
||||
iWrite = std::min(*pMax, iWrite);
|
||||
}
|
||||
for (unsigned int a = 0; a < iWrite; ++a) {
|
||||
pOut[a] = static_cast<ai_real>(reinterpret_cast<int32_t *>(prop->mData)[a]);
|
||||
}
|
||||
if (pMax) {
|
||||
*pMax = iWrite;
|
||||
}
|
||||
}
|
||||
// a string ... read floats separated by spaces
|
||||
else {
|
||||
if (pMax) {
|
||||
iWrite = *pMax;
|
||||
}
|
||||
// strings are zero-terminated with a 32 bit length prefix, so this is safe
|
||||
const char *cur = prop->mData + 4;
|
||||
ai_assert(prop->mDataLength >= 5);
|
||||
ai_assert(!prop->mData[prop->mDataLength - 1]);
|
||||
for (unsigned int a = 0;; ++a) {
|
||||
cur = fast_atoreal_move<double>(cur, pOut[a]);
|
||||
if (a == iWrite - 1) {
|
||||
break;
|
||||
}
|
||||
if (!IsSpace(*cur)) {
|
||||
ASSIMP_LOG_ERROR("Material property", pKey,
|
||||
" is a string; failed to parse a float array out of it.");
|
||||
return AI_FAILURE;
|
||||
}
|
||||
}
|
||||
|
||||
if (pMax) {
|
||||
*pMax = iWrite;
|
||||
}
|
||||
}
|
||||
return AI_SUCCESS;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Get an array if integers from the material
|
||||
aiReturn aiGetMaterialIntegerArray(const aiMaterial *pMat,
|
||||
|
|
|
@ -200,10 +200,8 @@ bool CalcTangentsProcess::ProcessMesh(aiMesh *pMesh, unsigned int meshIndex) {
|
|||
localBitangent.NormalizeSafe();
|
||||
|
||||
// reconstruct tangent/bitangent according to normal and bitangent/tangent when it's infinite or NaN.
|
||||
bool invalid_tangent = is_special_float(localTangent.x) || is_special_float(localTangent.y) || is_special_float(localTangent.z)
|
||||
|| (-0.5f < localTangent.x && localTangent.x < 0.5f && -0.5f < localTangent.y && localTangent.y < 0.5f && -0.5f < localTangent.z && localTangent.z < 0.5f);
|
||||
bool invalid_bitangent = is_special_float(localBitangent.x) || is_special_float(localBitangent.y) || is_special_float(localBitangent.z)
|
||||
|| (-0.5f < localBitangent.x && localBitangent.x < 0.5f && -0.5f < localBitangent.y && localBitangent.y < 0.5f && -0.5f < localBitangent.z && localBitangent.z < 0.5f);
|
||||
bool invalid_tangent = is_special_float(localTangent.x) || is_special_float(localTangent.y) || is_special_float(localTangent.z);
|
||||
bool invalid_bitangent = is_special_float(localBitangent.x) || is_special_float(localBitangent.y) || is_special_float(localBitangent.z);
|
||||
if (invalid_tangent != invalid_bitangent) {
|
||||
if (invalid_tangent) {
|
||||
localTangent = meshNorm[p] ^ localBitangent;
|
||||
|
|
|
@ -143,13 +143,9 @@ bool FindDegeneratesProcess::ExecuteOnMesh(aiMesh *mesh) {
|
|||
for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
|
||||
aiFace &face = mesh->mFaces[a];
|
||||
bool first = true;
|
||||
auto vertex_in_range = [numVertices = mesh->mNumVertices](unsigned int vertex_idx) { return vertex_idx < numVertices; };
|
||||
|
||||
// check whether the face contains degenerated entries
|
||||
for (unsigned int i = 0; i < face.mNumIndices; ++i) {
|
||||
if (!std::all_of(face.mIndices, face.mIndices + face.mNumIndices, vertex_in_range))
|
||||
continue;
|
||||
|
||||
// Polygons with more than 4 points are allowed to have double points, that is
|
||||
// simulating polygons with holes just with concave polygons. However,
|
||||
// double points may not come directly after another.
|
||||
|
|
|
@ -380,4 +380,3 @@ ai_real ImproveCacheLocalityProcess::ProcessMesh(aiMesh *pMesh, unsigned int mes
|
|||
}
|
||||
|
||||
} // namespace Assimp
|
||||
|
||||
|
|
|
@ -65,47 +65,37 @@ void SortByPTypeProcess::SetupProperties(const Importer *pImp) {
|
|||
mConfigRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, 0);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
static void clearMeshesInNode(aiNode *node) {
|
||||
delete[] node->mMeshes;
|
||||
node->mNumMeshes = 0;
|
||||
node->mMeshes = nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Update changed meshes in all nodes
|
||||
void UpdateNodes(const std::vector<unsigned int> &replaceMeshIndex, aiNode *node) {
|
||||
ai_assert(node != nullptr);
|
||||
|
||||
if (node->mNumMeshes) {
|
||||
unsigned int newSize = 0;
|
||||
for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
|
||||
unsigned int add = node->mMeshes[m] << 2;
|
||||
for (unsigned int i = 0; i < 4; ++i) {
|
||||
if (UINT_MAX != replaceMeshIndex[add + i]) {
|
||||
++newSize;
|
||||
}
|
||||
if (UINT_MAX != replaceMeshIndex[add + i]) ++newSize;
|
||||
}
|
||||
}
|
||||
if (newSize == 0) {
|
||||
clearMeshesInNode(node);
|
||||
return;
|
||||
}
|
||||
|
||||
// Try to reuse the old array if possible
|
||||
unsigned int *newMeshes = (newSize > node->mNumMeshes ? new unsigned int[newSize] : node->mMeshes);
|
||||
for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
|
||||
unsigned int add = node->mMeshes[m] << 2;
|
||||
for (unsigned int i = 0; i < 4; ++i) {
|
||||
if (UINT_MAX != replaceMeshIndex[add + i]) {
|
||||
*newMeshes++ = replaceMeshIndex[add + i];
|
||||
if (!newSize) {
|
||||
delete[] node->mMeshes;
|
||||
node->mNumMeshes = 0;
|
||||
node->mMeshes = nullptr;
|
||||
} else {
|
||||
// Try to reuse the old array if possible
|
||||
unsigned int *newMeshes = (newSize > node->mNumMeshes ? new unsigned int[newSize] : node->mMeshes);
|
||||
|
||||
for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
|
||||
unsigned int add = node->mMeshes[m] << 2;
|
||||
for (unsigned int i = 0; i < 4; ++i) {
|
||||
if (UINT_MAX != replaceMeshIndex[add + i])
|
||||
*newMeshes++ = replaceMeshIndex[add + i];
|
||||
}
|
||||
}
|
||||
if (newSize > node->mNumMeshes)
|
||||
delete[] node->mMeshes;
|
||||
|
||||
node->mMeshes = newMeshes - (node->mNumMeshes = newSize);
|
||||
}
|
||||
if (newSize > node->mNumMeshes) {
|
||||
clearMeshesInNode(node);
|
||||
}
|
||||
node->mMeshes = newMeshes - (node->mNumMeshes = newSize);
|
||||
}
|
||||
|
||||
// call all subnodes recursively
|
||||
|
@ -177,10 +167,6 @@ void SortByPTypeProcess::Execute(aiScene *pScene) {
|
|||
// with the largest number of primitives
|
||||
unsigned int aiNumPerPType[4] = { 0, 0, 0, 0 };
|
||||
aiFace *pFirstFace = mesh->mFaces;
|
||||
if (pFirstFace == nullptr) {
|
||||
continue;
|
||||
}
|
||||
|
||||
aiFace *const pLastFace = pFirstFace + mesh->mNumFaces;
|
||||
|
||||
unsigned int numPolyVerts = 0;
|
||||
|
|
|
@ -192,13 +192,13 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) {
|
|||
|
||||
for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
|
||||
const aiFace& face = pMesh->mFaces[a];
|
||||
|
||||
if( face.mNumIndices != 3) {
|
||||
bNeed = true;
|
||||
}
|
||||
}
|
||||
if (!bNeed) {
|
||||
if (!bNeed)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (!(pMesh->mPrimitiveTypes & aiPrimitiveType_POLYGON)) {
|
||||
return false;
|
||||
|
@ -213,7 +213,8 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) {
|
|||
get_normals = false;
|
||||
}
|
||||
if( face.mNumIndices <= 3) {
|
||||
++numOut;
|
||||
numOut++;
|
||||
|
||||
} else {
|
||||
numOut += face.mNumIndices-2;
|
||||
max_out = std::max(max_out,face.mNumIndices);
|
||||
|
@ -221,11 +222,8 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) {
|
|||
}
|
||||
|
||||
// Just another check whether aiMesh::mPrimitiveTypes is correct
|
||||
if (numOut == pMesh->mNumFaces) {
|
||||
ASSIMP_LOG_ERROR( "Invalidation detected in the number of indices: does not fit to the primitive type." );
|
||||
return false;
|
||||
}
|
||||
|
||||
ai_assert(numOut != pMesh->mNumFaces);
|
||||
|
||||
aiVector3D *nor_out = nullptr;
|
||||
|
||||
// if we don't have normals yet, but expect them to be a cheap side
|
||||
|
|
|
@ -371,7 +371,20 @@ void ValidateDSProcess::Validate(const aiMesh *pMesh) {
|
|||
ReportWarning("There are unreferenced vertices");
|
||||
}
|
||||
|
||||
// vertex color channel 2 may not be set if channel 1 is zero ...
|
||||
// texture channel 2 may not be set if channel 1 is zero ...
|
||||
{
|
||||
unsigned int i = 0;
|
||||
for (; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
|
||||
if (!pMesh->HasTextureCoords(i)) break;
|
||||
}
|
||||
for (; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i)
|
||||
if (pMesh->HasTextureCoords(i)) {
|
||||
ReportError("Texture coordinate channel %i exists "
|
||||
"although the previous channel was nullptr.",
|
||||
i);
|
||||
}
|
||||
}
|
||||
// the same for the vertex colors
|
||||
{
|
||||
unsigned int i = 0;
|
||||
for (; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
|
||||
|
@ -891,9 +904,6 @@ void ValidateDSProcess::Validate(const aiNode *pNode) {
|
|||
ReportError("aiNode \"%s\" child %i \"%s\" parent is someone else: \"%s\"", pNode->mName.C_Str(), i, pChild->mName.C_Str(), parentName);
|
||||
}
|
||||
}
|
||||
} else if (pNode->mChildren) {
|
||||
ReportError("aiNode::mChildren is not nullptr for empty node %s (aiNode::mNumChildren is %i)",
|
||||
nodeName, pNode->mNumChildren);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
All rights reserved.
|
||||
Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
http://code.google.com/p/poly2tri/
|
||||
|
||||
All rights reserved.
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
|
|
|
@ -0,0 +1,51 @@
|
|||
==================
|
||||
INSTALLATION GUIDE
|
||||
==================
|
||||
|
||||
------------
|
||||
Dependencies
|
||||
------------
|
||||
|
||||
Core poly2tri lib:
|
||||
- Standard Template Library (STL)
|
||||
|
||||
Testbed:
|
||||
- gcc
|
||||
- OpenGL
|
||||
- GLFW (http://glfw.sf.net)
|
||||
- Python
|
||||
|
||||
Waf (http://code.google.com/p/waf/) is used to compile the testbed.
|
||||
A waf script (86kb) is included in the repositoty.
|
||||
|
||||
----------------------------------------------
|
||||
Building the Testbed
|
||||
----------------------------------------------
|
||||
|
||||
Posix/MSYS environment:
|
||||
|
||||
./waf configure
|
||||
./waf build
|
||||
|
||||
Windows command line:
|
||||
|
||||
python waf configure
|
||||
python waf build
|
||||
|
||||
----------------------------------------------
|
||||
Running the Examples
|
||||
----------------------------------------------
|
||||
|
||||
Load data points from a file:
|
||||
p2t <filename> <center_x> <center_y> <zoom>
|
||||
|
||||
Random distribution of points inside a consrained box:
|
||||
p2t random <num_points> <box_radius> <zoom>
|
||||
|
||||
Examples:
|
||||
|
||||
./p2t dude.dat 300 500 2
|
||||
./p2t nazca_monkey.dat 0 0 9
|
||||
|
||||
./p2t random 10 100 5.0
|
||||
./p2t random 1000 20000 0.025
|
|
@ -1,101 +0,0 @@
|
|||
Since there are no Input validation of the data given for triangulation you need
|
||||
to think about this. Poly2Tri does not support repeat points within epsilon.
|
||||
|
||||
* If you have a cyclic function that generates random points make sure you don't
|
||||
add the same coordinate twice.
|
||||
* If you are given input and aren't sure same point exist twice you need to
|
||||
check for this yourself.
|
||||
* Only simple polygons are supported. You may add holes or interior Steiner points
|
||||
* Interior holes must not touch other holes, nor touch the polyline boundary
|
||||
* Use the library in this order:
|
||||
1. Initialize CDT with a simple polyline (this defines the constrained edges)
|
||||
2. Add holes if necessary (also simple polylines)
|
||||
3. Add Steiner points
|
||||
4. Triangulate
|
||||
|
||||
Make sure you understand the preceding notice before posting an issue. If you have
|
||||
an issue not covered by the above, include your data-set with the problem.
|
||||
The only easy day was yesterday; have a nice day. <Mason Green>
|
||||
|
||||
TESTBED INSTALLATION GUIDE
|
||||
==========================
|
||||
|
||||
Dependencies
|
||||
------------
|
||||
|
||||
Core poly2tri lib:
|
||||
|
||||
* Standard Template Library (STL)
|
||||
|
||||
Unit tests:
|
||||
* Boost (filesystem, test framework)
|
||||
|
||||
Testbed:
|
||||
|
||||
* OpenGL
|
||||
* [GLFW](http://glfw.sf.net)
|
||||
|
||||
Build the library
|
||||
-----------------
|
||||
|
||||
With the ninja build system installed:
|
||||
|
||||
```
|
||||
mkdir build && cd build
|
||||
cmake -GNinja ..
|
||||
cmake --build .
|
||||
```
|
||||
|
||||
Build and run with unit tests
|
||||
----------------------------
|
||||
|
||||
With the ninja build system:
|
||||
|
||||
```
|
||||
mkdir build && cd build
|
||||
cmake -GNinja -DP2T_BUILD_TESTS=ON ..
|
||||
cmake --build .
|
||||
ctest --output-on-failure
|
||||
```
|
||||
|
||||
Build with the testbed
|
||||
-----------------
|
||||
|
||||
```
|
||||
mkdir build && cd build
|
||||
cmake -GNinja -DP2T_BUILD_TESTBED=ON ..
|
||||
cmake --build .
|
||||
```
|
||||
|
||||
Running the Examples
|
||||
--------------------
|
||||
|
||||
Load data points from a file:
|
||||
```
|
||||
build/testbed/p2t <filename> <center_x> <center_y> <zoom>
|
||||
```
|
||||
Load data points from a file and automatically fit the geometry to the window:
|
||||
```
|
||||
build/testbed/p2t <filename>
|
||||
```
|
||||
Random distribution of points inside a constrained box:
|
||||
```
|
||||
build/testbed/p2t random <num_points> <box_radius> <zoom>
|
||||
```
|
||||
Examples:
|
||||
```
|
||||
build/testbed/p2t testbed/data/dude.dat 350 500 3
|
||||
|
||||
build/testbed/p2t testbed/data/nazca_monkey.dat
|
||||
|
||||
build/testbed/p2t random 10 100 5.0
|
||||
build/testbed/p2t random 1000 20000 0.025
|
||||
```
|
||||
|
||||
References
|
||||
==========
|
||||
|
||||
- Domiter V. and Zalik B. (2008) Sweep‐line algorithm for constrained Delaunay triangulation
|
||||
- FlipScan by library author Thomas Åhlén
|
||||
|
||||
![FlipScan](doc/FlipScan.png)
|
|
@ -1,61 +0,0 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2022, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
*
|
||||
* 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.
|
||||
* * Neither the name of Poly2Tri nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software without specific
|
||||
* prior written permission.
|
||||
*
|
||||
* 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
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma warning( disable: 4273)
|
||||
# define P2T_COMPILER_DLLEXPORT __declspec(dllexport)
|
||||
# define P2T_COMPILER_DLLIMPORT __declspec(dllimport)
|
||||
#elif defined(__GNUC__)
|
||||
# define P2T_COMPILER_DLLEXPORT __attribute__ ((visibility ("default")))
|
||||
# define P2T_COMPILER_DLLIMPORT __attribute__ ((visibility ("default")))
|
||||
#else
|
||||
# define P2T_COMPILER_DLLEXPORT
|
||||
# define P2T_COMPILER_DLLIMPORT
|
||||
#endif
|
||||
|
||||
// We need to enable shard linkage explicitely
|
||||
#ifdef ASSIMP_BUILD_DLL_EXPORT
|
||||
# define P2T_SHARED_EXPORTS 1
|
||||
#endif
|
||||
|
||||
#ifndef P2T_DLL_SYMBOL
|
||||
# if defined(P2T_STATIC_EXPORTS)
|
||||
# define P2T_DLL_SYMBOL
|
||||
# elif defined(P2T_SHARED_EXPORTS)
|
||||
# define P2T_DLL_SYMBOL P2T_COMPILER_DLLEXPORT
|
||||
# elif defined(BUILD_SHARED_LIBS)
|
||||
# define P2T_DLL_SYMBOL P2T_COMPILER_DLLIMPORT
|
||||
# else
|
||||
# define P2T_DLL_SYMBOL
|
||||
# endif
|
||||
#endif
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,24 +29,14 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "shapes.h"
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
namespace p2t {
|
||||
|
||||
Point::Point(double x, double y) : x(x), y(y)
|
||||
{
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const Point& point) {
|
||||
return out << point.x << "," << point.y;
|
||||
}
|
||||
|
||||
Triangle::Triangle(Point& a, Point& b, Point& c)
|
||||
{
|
||||
points_[0] = &a; points_[1] = &b; points_[2] = &c;
|
||||
neighbors_[0] = nullptr; neighbors_[1] = nullptr; neighbors_[2] = nullptr;
|
||||
neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
|
||||
constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false;
|
||||
delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
|
||||
interior_ = false;
|
||||
|
@ -86,37 +76,39 @@ void Triangle::MarkNeighbor(Triangle& t)
|
|||
void Triangle::Clear()
|
||||
{
|
||||
Triangle *t;
|
||||
for (auto& neighbor : neighbors_) {
|
||||
t = neighbor;
|
||||
if (t != nullptr) {
|
||||
t->ClearNeighbor(this);
|
||||
}
|
||||
for( int i=0; i<3; i++ )
|
||||
{
|
||||
t = neighbors_[i];
|
||||
if( t != NULL )
|
||||
{
|
||||
t->ClearNeighbor( this );
|
||||
}
|
||||
}
|
||||
ClearNeighbors();
|
||||
points_[0]=points_[1]=points_[2] = nullptr;
|
||||
points_[0]=points_[1]=points_[2] = NULL;
|
||||
}
|
||||
|
||||
void Triangle::ClearNeighbor(const Triangle *triangle )
|
||||
{
|
||||
if( neighbors_[0] == triangle )
|
||||
{
|
||||
neighbors_[0] = nullptr;
|
||||
neighbors_[0] = NULL;
|
||||
}
|
||||
else if( neighbors_[1] == triangle )
|
||||
{
|
||||
neighbors_[1] = nullptr;
|
||||
neighbors_[1] = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
neighbors_[2] = nullptr;
|
||||
neighbors_[2] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void Triangle::ClearNeighbors()
|
||||
{
|
||||
neighbors_[0] = nullptr;
|
||||
neighbors_[1] = nullptr;
|
||||
neighbors_[2] = nullptr;
|
||||
neighbors_[0] = NULL;
|
||||
neighbors_[1] = NULL;
|
||||
neighbors_[2] = NULL;
|
||||
}
|
||||
|
||||
void Triangle::ClearDelunayEdges()
|
||||
|
@ -228,7 +220,7 @@ Point* Triangle::PointCW(const Point& point)
|
|||
return points_[1];
|
||||
}
|
||||
assert(0);
|
||||
return nullptr;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// The point counter-clockwise to given point
|
||||
|
@ -242,18 +234,7 @@ Point* Triangle::PointCCW(const Point& point)
|
|||
return points_[0];
|
||||
}
|
||||
assert(0);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// The neighbor across to given point
|
||||
Triangle* Triangle::NeighborAcross(const Point& point)
|
||||
{
|
||||
if (&point == points_[0]) {
|
||||
return neighbors_[0];
|
||||
} else if (&point == points_[1]) {
|
||||
return neighbors_[1];
|
||||
}
|
||||
return neighbors_[2];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// The neighbor clockwise to given point
|
||||
|
@ -362,50 +343,23 @@ void Triangle::SetDelunayEdgeCW(const Point& p, bool e)
|
|||
}
|
||||
}
|
||||
|
||||
// The neighbor across to given point
|
||||
Triangle& Triangle::NeighborAcross(const Point& opoint)
|
||||
{
|
||||
if (&opoint == points_[0]) {
|
||||
return *neighbors_[0];
|
||||
} else if (&opoint == points_[1]) {
|
||||
return *neighbors_[1];
|
||||
}
|
||||
return *neighbors_[2];
|
||||
}
|
||||
|
||||
void Triangle::DebugPrint()
|
||||
{
|
||||
std::cout << *points_[0] << " " << *points_[1] << " " << *points_[2] << std::endl;
|
||||
using namespace std;
|
||||
cout << points_[0]->x << "," << points_[0]->y << " ";
|
||||
cout << points_[1]->x << "," << points_[1]->y << " ";
|
||||
cout << points_[2]->x << "," << points_[2]->y << endl;
|
||||
}
|
||||
|
||||
bool Triangle::CircumcicleContains(const Point& point) const
|
||||
{
|
||||
assert(IsCounterClockwise());
|
||||
const double dx = points_[0]->x - point.x;
|
||||
const double dy = points_[0]->y - point.y;
|
||||
const double ex = points_[1]->x - point.x;
|
||||
const double ey = points_[1]->y - point.y;
|
||||
const double fx = points_[2]->x - point.x;
|
||||
const double fy = points_[2]->y - point.y;
|
||||
|
||||
const double ap = dx * dx + dy * dy;
|
||||
const double bp = ex * ex + ey * ey;
|
||||
const double cp = fx * fx + fy * fy;
|
||||
|
||||
return (dx * (fy * bp - cp * ey) - dy * (fx * bp - cp * ex) + ap * (fx * ey - fy * ex)) < 0;
|
||||
}
|
||||
|
||||
bool Triangle::IsCounterClockwise() const
|
||||
{
|
||||
return (points_[1]->x - points_[0]->x) * (points_[2]->y - points_[0]->y) -
|
||||
(points_[2]->x - points_[0]->x) * (points_[1]->y - points_[0]->y) >
|
||||
0;
|
||||
}
|
||||
|
||||
bool IsDelaunay(const std::vector<p2t::Triangle*>& triangles)
|
||||
{
|
||||
for (const auto triangle : triangles) {
|
||||
for (const auto other : triangles) {
|
||||
if (triangle == other) {
|
||||
continue;
|
||||
}
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
if (triangle->CircumcicleContains(*other->GetPoint(i))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace p2t
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,24 +29,22 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
// Include guard
|
||||
#ifndef SHAPES_H
|
||||
#define SHAPES_H
|
||||
|
||||
#include "dll_symbol.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <cstddef>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
#include <assert.h>
|
||||
#include <cmath>
|
||||
#include <string>
|
||||
|
||||
|
||||
#if defined(_WIN32)
|
||||
# pragma warning( disable: 4251)
|
||||
#endif
|
||||
namespace p2t {
|
||||
|
||||
struct Edge;
|
||||
|
||||
struct P2T_DLL_SYMBOL Point {
|
||||
struct Point {
|
||||
|
||||
double x, y;
|
||||
|
||||
|
@ -61,7 +59,7 @@ struct P2T_DLL_SYMBOL Point {
|
|||
std::vector<Edge*> edge_list;
|
||||
|
||||
/// Construct using coordinates.
|
||||
Point(double x, double y);
|
||||
Point(double x, double y) : x(x), y(y) {}
|
||||
|
||||
/// Set this point to all zeros.
|
||||
void set_zero()
|
||||
|
@ -123,10 +121,8 @@ struct P2T_DLL_SYMBOL Point {
|
|||
|
||||
};
|
||||
|
||||
P2T_DLL_SYMBOL std::ostream& operator<<(std::ostream&, const Point&);
|
||||
|
||||
// Represents a simple polygon's edge
|
||||
struct P2T_DLL_SYMBOL Edge {
|
||||
struct Edge {
|
||||
|
||||
Point* p, *q;
|
||||
|
||||
|
@ -142,7 +138,9 @@ struct P2T_DLL_SYMBOL Edge {
|
|||
p = &p2;
|
||||
} else if (p1.x == p2.x) {
|
||||
// Repeat points
|
||||
throw std::runtime_error("Edge::Edge: p1 == p2");
|
||||
// ASSIMP_CHANGE (aramis_acg)
|
||||
throw std::runtime_error(std::string("repeat points"));
|
||||
//assert(false);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -153,7 +151,7 @@ struct P2T_DLL_SYMBOL Edge {
|
|||
// Triangle-based data structures are know to have better performance than quad-edge structures
|
||||
// See: J. Shewchuk, "Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator"
|
||||
// "Triangulations in CGAL"
|
||||
class P2T_DLL_SYMBOL Triangle {
|
||||
class Triangle {
|
||||
public:
|
||||
|
||||
/// Constructor
|
||||
|
@ -180,7 +178,6 @@ void MarkConstrainedEdge(Point* p, Point* q);
|
|||
int Index(const Point* p);
|
||||
int EdgeIndex(const Point* p1, const Point* p2);
|
||||
|
||||
Triangle* NeighborAcross(const Point& point);
|
||||
Triangle* NeighborCW(const Point& point);
|
||||
Triangle* NeighborCCW(const Point& point);
|
||||
bool GetConstrainedEdgeCCW(const Point& p);
|
||||
|
@ -208,14 +205,12 @@ void ClearDelunayEdges();
|
|||
inline bool IsInterior();
|
||||
inline void IsInterior(bool b);
|
||||
|
||||
Triangle& NeighborAcross(const Point& opoint);
|
||||
|
||||
void DebugPrint();
|
||||
|
||||
bool CircumcicleContains(const Point&) const;
|
||||
|
||||
private:
|
||||
|
||||
bool IsCounterClockwise() const;
|
||||
|
||||
/// Triangle points
|
||||
Point* points_[3];
|
||||
/// Neighbor list
|
||||
|
@ -263,7 +258,7 @@ inline bool operator ==(const Point& a, const Point& b)
|
|||
|
||||
inline bool operator !=(const Point& a, const Point& b)
|
||||
{
|
||||
return !(a.x == b.x) || !(a.y == b.y);
|
||||
return !(a.x == b.x) && !(a.y == b.y);
|
||||
}
|
||||
|
||||
/// Peform the dot product on two vectors.
|
||||
|
@ -327,7 +322,6 @@ inline void Triangle::IsInterior(bool b)
|
|||
interior_ = b;
|
||||
}
|
||||
|
||||
/// Is this set a valid delaunay triangulation?
|
||||
P2T_DLL_SYMBOL bool IsDelaunay(const std::vector<p2t::Triangle*>&);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,15 +29,14 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef UTILS_H
|
||||
#define UTILS_H
|
||||
|
||||
// Otherwise #defines like M_PI are undeclared under Visual Studio
|
||||
#define _USE_MATH_DEFINES
|
||||
|
||||
#include "shapes.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <exception>
|
||||
#include <math.h>
|
||||
|
||||
// C99 removes M_PI from math.h
|
||||
#ifndef M_PI
|
||||
|
@ -67,11 +66,7 @@ Orientation Orient2d(const Point& pa, const Point& pb, const Point& pc)
|
|||
double detleft = (pa.x - pc.x) * (pb.y - pc.y);
|
||||
double detright = (pa.y - pc.y) * (pb.x - pc.x);
|
||||
double val = detleft - detright;
|
||||
|
||||
// Using a tolerance here fails on concave-by-subepsilon boundaries
|
||||
// if (val > -EPSILON && val < EPSILON) {
|
||||
// Using == on double makes -Wfloat-equal warnings yell at us
|
||||
if (std::fpclassify(val) == FP_ZERO) {
|
||||
if (val > -EPSILON && val < EPSILON) {
|
||||
return COLLINEAR;
|
||||
} else if (val > 0) {
|
||||
return CCW;
|
||||
|
@ -128,3 +123,5 @@ bool InScanArea(const Point& pa, const Point& pb, const Point& pc, const Point&
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,7 +29,10 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef POLY2TRI_H
|
||||
#define POLY2TRI_H
|
||||
|
||||
#include "common/shapes.h"
|
||||
#include "sweep/cdt.h"
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -30,8 +30,6 @@
|
|||
*/
|
||||
#include "advancing_front.h"
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace p2t {
|
||||
|
||||
AdvancingFront::AdvancingFront(Node& head, Node& tail)
|
||||
|
@ -46,21 +44,21 @@ Node* AdvancingFront::LocateNode(double x)
|
|||
Node* node = search_node_;
|
||||
|
||||
if (x < node->value) {
|
||||
while ((node = node->prev) != nullptr) {
|
||||
while ((node = node->prev) != NULL) {
|
||||
if (x >= node->value) {
|
||||
search_node_ = node;
|
||||
return node;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
while ((node = node->next) != nullptr) {
|
||||
while ((node = node->next) != NULL) {
|
||||
if (x < node->value) {
|
||||
search_node_ = node->prev;
|
||||
return node->prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Node* AdvancingFront::FindSearchNode(double x)
|
||||
|
@ -88,13 +86,13 @@ Node* AdvancingFront::LocatePoint(const Point* point)
|
|||
}
|
||||
}
|
||||
} else if (px < nx) {
|
||||
while ((node = node->prev) != nullptr) {
|
||||
while ((node = node->prev) != NULL) {
|
||||
if (point == node->point) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
while ((node = node->next) != nullptr) {
|
||||
while ((node = node->next) != NULL) {
|
||||
if (point == node->point)
|
||||
break;
|
||||
}
|
||||
|
@ -107,4 +105,4 @@ AdvancingFront::~AdvancingFront()
|
|||
{
|
||||
}
|
||||
|
||||
} // namespace p2t
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,7 +29,8 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef ADVANCED_FRONT_H
|
||||
#define ADVANCED_FRONT_H
|
||||
|
||||
#include "../common/shapes.h"
|
||||
|
||||
|
@ -113,3 +114,5 @@ inline void AdvancingFront::set_search(Node* node)
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2021, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -68,4 +68,4 @@ CDT::~CDT()
|
|||
delete sweep_;
|
||||
}
|
||||
|
||||
} // namespace p2t
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,14 +29,13 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef CDT_H
|
||||
#define CDT_H
|
||||
|
||||
#include "advancing_front.h"
|
||||
#include "sweep_context.h"
|
||||
#include "sweep.h"
|
||||
|
||||
#include "../common/dll_symbol.h"
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Mason Green <mason.green@gmail.com>
|
||||
|
@ -45,7 +44,7 @@
|
|||
|
||||
namespace p2t {
|
||||
|
||||
class P2T_DLL_SYMBOL CDT
|
||||
class CDT
|
||||
{
|
||||
public:
|
||||
|
||||
|
@ -102,3 +101,5 @@ public:
|
|||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -28,21 +28,24 @@
|
|||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <stdexcept>
|
||||
#include "sweep.h"
|
||||
#include "sweep_context.h"
|
||||
#include "advancing_front.h"
|
||||
#include "../common/utils.h"
|
||||
|
||||
#include <cassert>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace p2t {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push)
|
||||
# pragma warning( disable : 4702 )
|
||||
#endif // _MSC_VER
|
||||
|
||||
// Triangulate simple polygon with holes
|
||||
void Sweep::Triangulate(SweepContext& tcx)
|
||||
{
|
||||
tcx.InitTriangulation();
|
||||
tcx.CreateAdvancingFront();
|
||||
tcx.CreateAdvancingFront(nodes_);
|
||||
// Sweep points; build mesh
|
||||
SweepPoints(tcx);
|
||||
// Clean up
|
||||
|
@ -54,8 +57,8 @@ void Sweep::SweepPoints(SweepContext& tcx)
|
|||
for (size_t i = 1; i < tcx.point_count(); i++) {
|
||||
Point& point = *tcx.GetPoint(i);
|
||||
Node* node = &PointEvent(tcx, point);
|
||||
for (auto& j : point.edge_list) {
|
||||
EdgeEvent(tcx, j, node);
|
||||
for (unsigned int ii = 0; ii < point.edge_list.size(); ii++) {
|
||||
EdgeEvent(tcx, point.edge_list[ii], node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -65,25 +68,17 @@ void Sweep::FinalizationPolygon(SweepContext& tcx)
|
|||
// Get an Internal triangle to start with
|
||||
Triangle* t = tcx.front()->head()->next->triangle;
|
||||
Point* p = tcx.front()->head()->next->point;
|
||||
while (t && !t->GetConstrainedEdgeCW(*p)) {
|
||||
while (!t->GetConstrainedEdgeCW(*p)) {
|
||||
t = t->NeighborCCW(*p);
|
||||
}
|
||||
|
||||
// Collect interior triangles constrained by edges
|
||||
if (t) {
|
||||
tcx.MeshClean(*t);
|
||||
}
|
||||
tcx.MeshClean(*t);
|
||||
}
|
||||
|
||||
Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
|
||||
{
|
||||
Node* node_ptr = tcx.LocateNode(point);
|
||||
if (!node_ptr || !node_ptr->point || !node_ptr->next || !node_ptr->next->point)
|
||||
{
|
||||
throw std::runtime_error("PointEvent - null node");
|
||||
}
|
||||
|
||||
Node& node = *node_ptr;
|
||||
Node& node = tcx.LocateNode(point);
|
||||
Node& new_node = NewFrontTriangle(tcx, point, node);
|
||||
|
||||
// Only need to check +epsilon since point never have smaller
|
||||
|
@ -116,9 +111,9 @@ void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node* node)
|
|||
|
||||
void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point)
|
||||
{
|
||||
if (triangle == nullptr) {
|
||||
throw std::runtime_error("EdgeEvent - null triangle");
|
||||
}
|
||||
if (triangle == nullptr)
|
||||
return;
|
||||
|
||||
if (IsEdgeSideOfTriangle(*triangle, ep, eq)) {
|
||||
return;
|
||||
}
|
||||
|
@ -126,14 +121,17 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
|
|||
Point* p1 = triangle->PointCCW(point);
|
||||
Orientation o1 = Orient2d(eq, *p1, ep);
|
||||
if (o1 == COLLINEAR) {
|
||||
if (triangle->Contains(&eq, p1)) {
|
||||
triangle->MarkConstrainedEdge(&eq, p1);
|
||||
|
||||
|
||||
if( triangle->Contains(&eq, p1)) {
|
||||
triangle->MarkConstrainedEdge(&eq, p1 );
|
||||
// We are modifying the constraint maybe it would be better to
|
||||
// not change the given constraint and just keep a variable for the new constraint
|
||||
tcx.edge_event.constrained_edge->q = p1;
|
||||
triangle = triangle->NeighborAcross(point);
|
||||
EdgeEvent(tcx, ep, *p1, triangle, *p1);
|
||||
triangle = &triangle->NeighborAcross(point);
|
||||
EdgeEvent( tcx, ep, *p1, triangle, *p1 );
|
||||
} else {
|
||||
// ASSIMP_CHANGE (aramis_acg)
|
||||
throw std::runtime_error("EdgeEvent - collinear points not supported");
|
||||
}
|
||||
return;
|
||||
|
@ -142,14 +140,18 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
|
|||
Point* p2 = triangle->PointCW(point);
|
||||
Orientation o2 = Orient2d(eq, *p2, ep);
|
||||
if (o2 == COLLINEAR) {
|
||||
if (triangle->Contains(&eq, p2)) {
|
||||
triangle->MarkConstrainedEdge(&eq, p2);
|
||||
|
||||
|
||||
|
||||
if( triangle->Contains(&eq, p2)) {
|
||||
triangle->MarkConstrainedEdge(&eq, p2 );
|
||||
// We are modifying the constraint maybe it would be better to
|
||||
// not change the given constraint and just keep a variable for the new constraint
|
||||
tcx.edge_event.constrained_edge->q = p2;
|
||||
triangle = triangle->NeighborAcross(point);
|
||||
EdgeEvent(tcx, ep, *p2, triangle, *p2);
|
||||
triangle = &triangle->NeighborAcross(point);
|
||||
EdgeEvent( tcx, ep, *p2, triangle, *p2 );
|
||||
} else {
|
||||
// ASSIMP_CHANGE (aramis_acg)
|
||||
throw std::runtime_error("EdgeEvent - collinear points not supported");
|
||||
}
|
||||
return;
|
||||
|
@ -160,13 +162,12 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
|
|||
// that will cross edge
|
||||
if (o1 == CW) {
|
||||
triangle = triangle->NeighborCCW(point);
|
||||
} else {
|
||||
} else{
|
||||
triangle = triangle->NeighborCW(point);
|
||||
}
|
||||
EdgeEvent(tcx, ep, eq, triangle, point);
|
||||
} else {
|
||||
// This triangle crosses constraint so lets flippin start!
|
||||
assert(triangle);
|
||||
FlipEdgeEvent(tcx, ep, eq, triangle, point);
|
||||
}
|
||||
}
|
||||
|
@ -227,6 +228,7 @@ void Sweep::Fill(SweepContext& tcx, Node& node)
|
|||
if (!Legalize(tcx, *triangle)) {
|
||||
tcx.MapTriangleToNodes(*triangle);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
|
||||
|
@ -235,7 +237,7 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
|
|||
// Fill right holes
|
||||
Node* node = n.next;
|
||||
|
||||
while (node && node->next) {
|
||||
while (node->next) {
|
||||
// if HoleAngle exceeds 90 degrees then break.
|
||||
if (LargeHole_DontFill(node)) break;
|
||||
Fill(tcx, *node);
|
||||
|
@ -245,7 +247,7 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
|
|||
// Fill left holes
|
||||
node = n.prev;
|
||||
|
||||
while (node && node->prev) {
|
||||
while (node->prev) {
|
||||
// if HoleAngle exceeds 90 degrees then break.
|
||||
if (LargeHole_DontFill(node)) break;
|
||||
Fill(tcx, *node);
|
||||
|
@ -262,35 +264,6 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
|
|||
}
|
||||
|
||||
// True if HoleAngle exceeds 90 degrees.
|
||||
// LargeHole_DontFill checks if the advancing front has a large hole.
|
||||
// A "Large hole" is a triangle formed by a sequence of points in the advancing
|
||||
// front where three neighbor points form a triangle.
|
||||
// And angle between left-top, bottom, and right-top points is more than 90 degrees.
|
||||
// The first part of the algorithm reviews only three neighbor points, e.g. named A, B, C.
|
||||
// Additional part of this logic reviews a sequence of 5 points -
|
||||
// additionally reviews one point before and one after the sequence of three (A, B, C),
|
||||
// e.g. named X and Y.
|
||||
// In this case, angles are XBC and ABY and this if angles are negative or more
|
||||
// than 90 degrees LargeHole_DontFill returns true.
|
||||
// But there is a configuration when ABC has a negative angle but XBC or ABY is less
|
||||
// than 90 degrees and positive.
|
||||
// Then function LargeHole_DontFill return false and initiates filling.
|
||||
// This filling creates a triangle ABC and adds it to the advancing front.
|
||||
// But in the case when angle ABC is negative this triangle goes inside the advancing front
|
||||
// and can intersect previously created triangles.
|
||||
// This triangle leads to making wrong advancing front and problems in triangulation in the future.
|
||||
// Looks like such a triangle should not be created.
|
||||
// The simplest way to check and fix it is to check an angle ABC.
|
||||
// If it is negative LargeHole_DontFill should return true and
|
||||
// not initiate creating the ABC triangle in the advancing front.
|
||||
// X______A Y
|
||||
// \ /
|
||||
// \ /
|
||||
// \ B /
|
||||
// | /
|
||||
// | /
|
||||
// |/
|
||||
// C
|
||||
bool Sweep::LargeHole_DontFill(const Node* node) const {
|
||||
|
||||
const Node* nextNode = node->next;
|
||||
|
@ -298,28 +271,20 @@ bool Sweep::LargeHole_DontFill(const Node* node) const {
|
|||
if (!AngleExceeds90Degrees(node->point, nextNode->point, prevNode->point))
|
||||
return false;
|
||||
|
||||
if (AngleIsNegative(node->point, nextNode->point, prevNode->point))
|
||||
return true;
|
||||
|
||||
// Check additional points on front.
|
||||
const Node* next2Node = nextNode->next;
|
||||
// "..Plus.." because only want angles on same side as point being added.
|
||||
if ((next2Node != nullptr) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point))
|
||||
if ((next2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point))
|
||||
return false;
|
||||
|
||||
const Node* prev2Node = prevNode->prev;
|
||||
// "..Plus.." because only want angles on same side as point being added.
|
||||
if ((prev2Node != nullptr) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point))
|
||||
if ((prev2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Sweep::AngleIsNegative(const Point* origin, const Point* pa, const Point* pb) const {
|
||||
const double angle = Angle(origin, pa, pb);
|
||||
return angle < 0;
|
||||
}
|
||||
|
||||
bool Sweep::AngleExceeds90Degrees(const Point* origin, const Point* pa, const Point* pb) const {
|
||||
const double angle = Angle(origin, pa, pb);
|
||||
return ((angle > PI_div2) || (angle < -PI_div2));
|
||||
|
@ -341,7 +306,7 @@ double Sweep::Angle(const Point* origin, const Point* pa, const Point* pb) const
|
|||
*/
|
||||
const double px = origin->x;
|
||||
const double py = origin->y;
|
||||
const double ax = pa->x - px;
|
||||
const double ax = pa->x- px;
|
||||
const double ay = pa->y - py;
|
||||
const double bx = pb->x - px;
|
||||
const double by = pb->y - py;
|
||||
|
@ -634,7 +599,7 @@ void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
|
|||
if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
|
||||
// Concave
|
||||
FillRightConcaveEdgeEvent(tcx, edge, node);
|
||||
} else {
|
||||
} else{
|
||||
// Convex
|
||||
FillRightConvexEdgeEvent(tcx, edge, node);
|
||||
// Retry this one
|
||||
|
@ -658,6 +623,7 @@ void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
|
||||
|
@ -666,13 +632,13 @@ void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
|
|||
if (Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point) == CCW) {
|
||||
// Concave
|
||||
FillRightConcaveEdgeEvent(tcx, edge, *node.next);
|
||||
} else {
|
||||
} else{
|
||||
// Convex
|
||||
// Next above or below edge?
|
||||
if (Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) {
|
||||
// Below
|
||||
FillRightConvexEdgeEvent(tcx, edge, *node.next);
|
||||
} else {
|
||||
} else{
|
||||
// Above
|
||||
}
|
||||
}
|
||||
|
@ -711,13 +677,13 @@ void Sweep::FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
|
|||
if (Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) {
|
||||
// Concave
|
||||
FillLeftConcaveEdgeEvent(tcx, edge, *node.prev);
|
||||
} else {
|
||||
} else{
|
||||
// Convex
|
||||
// Next above or below edge?
|
||||
if (Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) {
|
||||
// Below
|
||||
FillLeftConvexEdgeEvent(tcx, edge, *node.prev);
|
||||
} else {
|
||||
} else{
|
||||
// Above
|
||||
}
|
||||
}
|
||||
|
@ -733,22 +699,17 @@ void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
|
|||
if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
|
||||
// Next is concave
|
||||
FillLeftConcaveEdgeEvent(tcx, edge, node);
|
||||
} else {
|
||||
} else{
|
||||
// Next is convex
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p)
|
||||
{
|
||||
assert(t);
|
||||
Triangle* ot_ptr = t->NeighborAcross(p);
|
||||
if (ot_ptr == nullptr)
|
||||
{
|
||||
throw std::runtime_error("FlipEdgeEvent - null neighbor across");
|
||||
}
|
||||
Triangle& ot = *ot_ptr;
|
||||
Triangle& ot = t->NeighborAcross(p);
|
||||
Point& op = *ot.OppositePoint(*t, p);
|
||||
|
||||
if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) {
|
||||
|
@ -814,26 +775,10 @@ Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op)
|
|||
void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle,
|
||||
Triangle& t, Point& p)
|
||||
{
|
||||
Triangle* ot_ptr = t.NeighborAcross(p);
|
||||
if (ot_ptr == nullptr) {
|
||||
throw std::runtime_error("FlipScanEdgeEvent - null neighbor across");
|
||||
}
|
||||
Triangle& ot = t.NeighborAcross(p);
|
||||
Point& op = *ot.OppositePoint(t, p);
|
||||
|
||||
Point* op_ptr = ot_ptr->OppositePoint(t, p);
|
||||
if (op_ptr == nullptr) {
|
||||
throw std::runtime_error("FlipScanEdgeEvent - null opposing point");
|
||||
}
|
||||
|
||||
Point* p1 = flip_triangle.PointCCW(eq);
|
||||
Point* p2 = flip_triangle.PointCW(eq);
|
||||
if (p1 == nullptr || p2 == nullptr) {
|
||||
throw std::runtime_error("FlipScanEdgeEvent - null on either of points");
|
||||
}
|
||||
|
||||
Triangle& ot = *ot_ptr;
|
||||
Point& op = *op_ptr;
|
||||
|
||||
if (InScanArea(eq, *p1, *p2, op)) {
|
||||
if (InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW(eq), op)) {
|
||||
// flip with new edge op->eq
|
||||
FlipEdgeEvent(tcx, eq, op, &ot, op);
|
||||
// TODO: Actually I just figured out that it should be possible to
|
||||
|
@ -843,7 +788,7 @@ void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle&
|
|||
// also need to set a new flip_triangle first
|
||||
// Turns out at first glance that this is somewhat complicated
|
||||
// so it will have to wait.
|
||||
} else {
|
||||
} else{
|
||||
Point& newP = NextFlipPoint(ep, eq, ot, op);
|
||||
FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP);
|
||||
}
|
||||
|
@ -852,9 +797,14 @@ void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle&
|
|||
Sweep::~Sweep() {
|
||||
|
||||
// Clean up memory
|
||||
for (auto& node : nodes_) {
|
||||
delete node;
|
||||
for(size_t i = 0; i < nodes_.size(); i++) {
|
||||
delete nodes_[i];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} // namespace p2t
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning( pop )
|
||||
#endif // _MSC_VER
|
||||
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2018, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -33,10 +33,11 @@
|
|||
* Zalik, B.(2008)'Sweep-line algorithm for constrained Delaunay triangulation',
|
||||
* International Journal of Geographical Information Science
|
||||
*
|
||||
* "FlipScan" Constrained Edge Algorithm invented by Thomas Åhlén, thahlen@gmail.com
|
||||
* "FlipScan" Constrained Edge Algorithm invented by Thomas ?hl?n, thahlen@gmail.com
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef SWEEP_H
|
||||
#define SWEEP_H
|
||||
|
||||
#include <vector>
|
||||
|
||||
|
@ -171,7 +172,6 @@ private:
|
|||
// Decision-making about when to Fill hole.
|
||||
// Contributed by ToolmakerSteve2
|
||||
bool LargeHole_DontFill(const Node* node) const;
|
||||
bool AngleIsNegative(const Point* origin, const Point* pa, const Point* pb) const;
|
||||
bool AngleExceeds90Degrees(const Point* origin, const Point* pa, const Point* pb) const;
|
||||
bool AngleExceedsPlus90DegreesOrIsNegative(const Point* origin, const Point* pa, const Point* pb) const;
|
||||
double Angle(const Point* origin, const Point* pa, const Point* pb) const;
|
||||
|
@ -281,3 +281,5 @@ private:
|
|||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2022, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -34,13 +34,13 @@
|
|||
|
||||
namespace p2t {
|
||||
|
||||
SweepContext::SweepContext(std::vector<Point*> polyline) : points_(std::move(polyline)),
|
||||
front_(nullptr),
|
||||
head_(nullptr),
|
||||
tail_(nullptr),
|
||||
af_head_(nullptr),
|
||||
af_middle_(nullptr),
|
||||
af_tail_(nullptr)
|
||||
SweepContext::SweepContext(const std::vector<Point*>& polyline) : points_(polyline),
|
||||
front_(0),
|
||||
head_(0),
|
||||
tail_(0),
|
||||
af_head_(0),
|
||||
af_middle_(0),
|
||||
af_tail_(0)
|
||||
{
|
||||
InitEdges(points_);
|
||||
}
|
||||
|
@ -48,8 +48,8 @@ SweepContext::SweepContext(std::vector<Point*> polyline) : points_(std::move(pol
|
|||
void SweepContext::AddHole(const std::vector<Point*>& polyline)
|
||||
{
|
||||
InitEdges(polyline);
|
||||
for (auto i : polyline) {
|
||||
points_.push_back(i);
|
||||
for(unsigned int i = 0; i < polyline.size(); i++) {
|
||||
points_.push_back(polyline[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -73,8 +73,8 @@ void SweepContext::InitTriangulation()
|
|||
double ymax(points_[0]->y), ymin(points_[0]->y);
|
||||
|
||||
// Calculate bounds.
|
||||
for (auto& point : points_) {
|
||||
Point& p = *point;
|
||||
for (unsigned int i = 0; i < points_.size(); i++) {
|
||||
Point& p = *points_[i];
|
||||
if (p.x > xmax)
|
||||
xmax = p.x;
|
||||
if (p.x < xmin)
|
||||
|
@ -87,8 +87,8 @@ void SweepContext::InitTriangulation()
|
|||
|
||||
double dx = kAlpha * (xmax - xmin);
|
||||
double dy = kAlpha * (ymax - ymin);
|
||||
head_ = new Point(xmin - dx, ymin - dy);
|
||||
tail_ = new Point(xmax + dx, ymin - dy);
|
||||
head_ = new Point(xmax + dx, ymin - dy);
|
||||
tail_ = new Point(xmin - dx, ymin - dy);
|
||||
|
||||
// Sort points along y-axis
|
||||
std::sort(points_.begin(), points_.end(), cmp);
|
||||
|
@ -114,17 +114,18 @@ void SweepContext::AddToMap(Triangle* triangle)
|
|||
map_.push_back(triangle);
|
||||
}
|
||||
|
||||
Node* SweepContext::LocateNode(const Point& point)
|
||||
Node& SweepContext::LocateNode(const Point& point)
|
||||
{
|
||||
// TODO implement search tree
|
||||
return front_->LocateNode(point.x);
|
||||
return *front_->LocateNode(point.x);
|
||||
}
|
||||
|
||||
void SweepContext::CreateAdvancingFront()
|
||||
void SweepContext::CreateAdvancingFront(const std::vector<Node*>& nodes)
|
||||
{
|
||||
|
||||
(void) nodes;
|
||||
// Initial triangle
|
||||
Triangle* triangle = new Triangle(*points_[0], *head_, *tail_);
|
||||
Triangle* triangle = new Triangle(*points_[0], *tail_, *head_);
|
||||
|
||||
map_.push_back(triangle);
|
||||
|
||||
|
@ -171,7 +172,7 @@ void SweepContext::MeshClean(Triangle& triangle)
|
|||
Triangle *t = triangles.back();
|
||||
triangles.pop_back();
|
||||
|
||||
if (t != nullptr && !t->IsInterior()) {
|
||||
if (t != NULL && !t->IsInterior()) {
|
||||
t->IsInterior(true);
|
||||
triangles_.push_back(t);
|
||||
for (int i = 0; i < 3; i++) {
|
||||
|
@ -194,13 +195,17 @@ SweepContext::~SweepContext()
|
|||
delete af_middle_;
|
||||
delete af_tail_;
|
||||
|
||||
for (auto ptr : map_) {
|
||||
delete ptr;
|
||||
typedef std::list<Triangle*> type_list;
|
||||
|
||||
for(type_list::iterator iter = map_.begin(); iter != map_.end(); ++iter) {
|
||||
Triangle* ptr = *iter;
|
||||
delete ptr;
|
||||
}
|
||||
|
||||
for (auto& i : edge_list) {
|
||||
delete i;
|
||||
for(unsigned int i = 0; i < edge_list.size(); i++) {
|
||||
delete edge_list[i];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} // namespace p2t
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Poly2Tri Copyright (c) 2009-2022, Poly2Tri Contributors
|
||||
* https://github.com/jhasse/poly2tri
|
||||
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
||||
* http://code.google.com/p/poly2tri/
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -29,7 +29,8 @@
|
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef SWEEP_CONTEXT_H
|
||||
#define SWEEP_CONTEXT_H
|
||||
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
@ -51,7 +52,7 @@ class SweepContext {
|
|||
public:
|
||||
|
||||
/// Constructor
|
||||
explicit SweepContext(std::vector<Point*> polyline);
|
||||
SweepContext(const std::vector<Point*>& polyline);
|
||||
/// Destructor
|
||||
~SweepContext();
|
||||
|
||||
|
@ -65,11 +66,11 @@ Point* tail() const;
|
|||
|
||||
size_t point_count() const;
|
||||
|
||||
Node* LocateNode(const Point& point);
|
||||
Node& LocateNode(const Point& point);
|
||||
|
||||
void RemoveNode(Node* node);
|
||||
|
||||
void CreateAdvancingFront();
|
||||
void CreateAdvancingFront(const std::vector<Node*>& nodes);
|
||||
|
||||
/// Try to map a node to all sides of this triangle that don't have a neighbor
|
||||
void MapTriangleToNodes(Triangle& t);
|
||||
|
@ -102,16 +103,15 @@ struct Basin {
|
|||
double width;
|
||||
bool left_highest;
|
||||
|
||||
Basin()
|
||||
: left_node(nullptr), bottom_node(nullptr), right_node(nullptr), width(0.0), left_highest(false)
|
||||
Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL), width(0.0), left_highest(false)
|
||||
{
|
||||
}
|
||||
|
||||
void Clear()
|
||||
{
|
||||
left_node = nullptr;
|
||||
bottom_node = nullptr;
|
||||
right_node = nullptr;
|
||||
left_node = NULL;
|
||||
bottom_node = NULL;
|
||||
right_node = NULL;
|
||||
width = 0.0;
|
||||
left_highest = false;
|
||||
}
|
||||
|
@ -182,3 +182,5 @@ inline Point* SweepContext::tail() const
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,13 +0,0 @@
|
|||
# tinyusdz
|
||||
"tinyusdz" C++ project provides USD/USDA/UDSC/UDSZ 3D model file format suport
|
||||
|
||||
## Automatic repo clone
|
||||
tinyusdz repo is automatically cloned. Users who haven't opted-in to USD support
|
||||
won't be burdened with the extra download volume.
|
||||
|
||||
To update te git commit hash pulled down, modify `TINYUSDZ_GIT_TAG` in file
|
||||
`code/CMakeLists.txt`
|
||||
|
||||
## Notes
|
||||
Couldn't leverage tinyusdz CMakeLists.txt. Fell back to compiling source files specified in
|
||||
"android" example.
|
|
@ -1,57 +0,0 @@
|
|||
/**
|
||||
* Usage
|
||||
* Add line below all other #include statements:
|
||||
* #include "../../../assimp_tinyusdz_logging.inc"
|
||||
* to files:
|
||||
* - contrib/tinyusdz/tinyusdz_repo/src/tydra/render-data.cc
|
||||
* - contrib/tinyusdz/tinyusdz_repo/src/tydra/scene-access.cc
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#if defined(__ANDROID__)
|
||||
#include <sstream>
|
||||
#include <android/log.h>
|
||||
|
||||
#define TINYUSDZLOGT(tag, ...) ((void)__android_log_print(ANDROID_LOG_DEBUG, tag, __VA_ARGS__))
|
||||
#define TINYUSDZLOG0(tag, ...) ((void)__android_log_print(ANDROID_LOG_DEFAULT, tag, __VA_ARGS__))
|
||||
#define TINYUSDZLOGD(tag, ...) ((void)__android_log_print(ANDROID_LOG_DEBUG, tag, __VA_ARGS__))
|
||||
#define TINYUSDZLOGI(tag, ...) ((void)__android_log_print(ANDROID_LOG_INFO, tag, __VA_ARGS__))
|
||||
#define TINYUSDZLOGW(tag, ...) ((void)__android_log_print(ANDROID_LOG_WARN, tag, __VA_ARGS__))
|
||||
#define TINYUSDZLOGE(tag, ...) ((void)__android_log_print(ANDROID_LOG_ERROR, tag, __VA_ARGS__))
|
||||
#else
|
||||
#define TINYUSDZLOGT(tag, ...)
|
||||
#define TINYUSDZLOG0(tag, ...)
|
||||
#define TINYUSDZLOGD(tag, ...)
|
||||
#define TINYUSDZLOGI(tag, ...)
|
||||
#define TINYUSDZLOGW(tag, ...)
|
||||
#define TINYUSDZLOGE(tag, ...)
|
||||
#endif // #if defined(__ANDROID__)
|
||||
|
||||
#if defined(TINYUSDZ_LOCAL_DEBUG_PRINT)
|
||||
#if defined(__ANDROID__)
|
||||
#if defined(ASSIMP_USD_VERBOSE_LOGS)
|
||||
// Works well but _extremely_ verbose
|
||||
#define DCOUT(x) \
|
||||
do { \
|
||||
std::stringstream ss; \
|
||||
ss << __FILE__ << ":" << __func__ << ":" \
|
||||
<< std::to_string(__LINE__) << " " << x << "\n"; \
|
||||
TINYUSDZLOGE("tinyusdz", "%s", ss.str().c_str()); \
|
||||
} while (false)
|
||||
#else // defined(ASSIMP_USD_VERBOSE_LOGS)
|
||||
// Silent version
|
||||
#define DCOUT(x) \
|
||||
do { \
|
||||
std::stringstream ss; \
|
||||
ss << __FILE__ << ":" << __func__ << ":" \
|
||||
<< std::to_string(__LINE__) << " " << x << "\n"; \
|
||||
} while (false)
|
||||
#endif // defined(ASSIMP_USD_VERBOSE_LOGS)
|
||||
#else // defined(__ANDROID__)
|
||||
#define DCOUT(x) \
|
||||
do { \
|
||||
std::cout << __FILE__ << ":" << __func__ << ":" \
|
||||
<< std::to_string(__LINE__) << " " << x << "\n"; \
|
||||
} while (false)
|
||||
#endif // #if defined(__ANDROID__)
|
||||
#endif // #if defined(TINYUSDZ_LOCAL_DEBUG_PRINT)
|
|
@ -1,40 +0,0 @@
|
|||
# Tinyusdz patch files
|
||||
|
||||
Pending acceptance of proposed changes upstream, need to resort to patching to keep things moving
|
||||
|
||||
## Tinyusdz files needing patches
|
||||
|
||||
### `tinyusdz_repo/src/external/stb_image_resize2.h`
|
||||
Without patch, build will fail for armeabi-v7a ABI via android NDK
|
||||
|
||||
Add `#elif` block as indicated below around line `2407`
|
||||
```
|
||||
#elif defined(STBIR_WASM) || (defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM)) // WASM or 32-bit ARM on MSVC/clang
|
||||
...
|
||||
#elif defined(STBIR_NEON) && (defined(__ANDROID__) && defined(__arm__)) // 32-bit ARM on android NDK
|
||||
|
||||
static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
|
||||
{
|
||||
// TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
}
|
||||
|
||||
static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)
|
||||
{
|
||||
// TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
}
|
||||
|
||||
static stbir__inline float stbir__half_to_float( stbir__FP16 h )
|
||||
{
|
||||
// TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
return 0;
|
||||
}
|
||||
|
||||
static stbir__inline stbir__FP16 stbir__float_to_half( float f )
|
||||
{
|
||||
// TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
return 0;
|
||||
}
|
||||
|
||||
#elif defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__) // 64-bit ARM on MSVC (not clang)
|
||||
```
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
diff -rupN -x .git autoclone/tinyusdz_repo-src/src/external/stb_image_resize2.h tinyusdz_repo_patch/src/external/stb_image_resize2.h
|
||||
--- autoclone/tinyusdz_repo-src/src/external/stb_image_resize2.h 2024-07-09 21:29:48.556969900 -0700
|
||||
+++ tinyusdz_repo_patch/src/external/stb_image_resize2.h 2024-07-09 23:03:47.379316700 -0700
|
||||
@@ -2404,6 +2404,38 @@ static stbir__inline stbir_uint8 stbir__
|
||||
}
|
||||
}
|
||||
|
||||
+#elif defined(STBIR_NEON) && (defined(__ANDROID__) && defined(__arm__)) // 32-bit ARM on android NDK
|
||||
+
|
||||
+ // TODO As of Apr 2024, tinyusdz doesn't support building on armeabi-v7a (32 bit arm) for android
|
||||
+ // (falls through to arm64 block and build fails)
|
||||
+ //
|
||||
+ // For assimp integration, the image processing utilities aren't used at all, so it's safe to
|
||||
+ // essentially replace the functions with dummy no-ops.
|
||||
+ //
|
||||
+ // This will need to be done manually whenever the tinyusdz source files are updated in assimp,
|
||||
+ // as it seems unlikely this will be fixed in the tinyusdz project
|
||||
+ static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
|
||||
+ {
|
||||
+ // TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
+ }
|
||||
+
|
||||
+ static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)
|
||||
+ {
|
||||
+ // TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
+ }
|
||||
+
|
||||
+ static stbir__inline float stbir__half_to_float( stbir__FP16 h )
|
||||
+ {
|
||||
+ // TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ static stbir__inline stbir__FP16 stbir__float_to_half( float f )
|
||||
+ {
|
||||
+ // TODO: this stub is just to allow build on armeabi-v7a via android NDK
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
#elif defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__) // 64-bit ARM on MSVC (not clang)
|
||||
|
||||
static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
|
|
@ -60,7 +60,6 @@ __Importers__:
|
|||
- [STL](https://en.wikipedia.org/wiki/STL_(file_format))
|
||||
- TER
|
||||
- UC
|
||||
- [USD](https://en.wikipedia.org/wiki/Universal_Scene_Description)
|
||||
- VTA
|
||||
- X
|
||||
- [X3D](https://en.wikipedia.org/wiki/X3D)
|
||||
|
|
|
@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
using namespace Assimp;
|
||||
|
||||
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize) {
|
||||
aiLogStream stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT, nullptr);
|
||||
aiLogStream stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
|
||||
aiAttachLogStream(&stream);
|
||||
|
||||
Importer importer;
|
||||
|
|
|
@ -277,8 +277,7 @@ public: // static utilities
|
|||
const std::string &pFile,
|
||||
const char *ext0,
|
||||
const char *ext1 = nullptr,
|
||||
const char *ext2 = nullptr,
|
||||
const char *ext3 = nullptr);
|
||||
const char *ext2 = nullptr);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** @brief Check whether a file has one of the passed file extensions
|
||||
|
|
|
@ -79,7 +79,7 @@ public:
|
|||
unsigned int pElementOffset);
|
||||
|
||||
/** Destructor */
|
||||
~SpatialSort() = default;
|
||||
~SpatialSort();
|
||||
|
||||
// ------------------------------------------------------------------------------------
|
||||
/** Sets the input data for the SpatialSort. This replaces existing data, if any.
|
||||
|
|
|
@ -57,6 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <assimp/StringComparison.h>
|
||||
#include <assimp/ai_assert.h>
|
||||
#include <assimp/defs.h>
|
||||
|
||||
|
|
|
@ -4,6 +4,7 @@ Open Asset Import Library (assimp)
|
|||
|
||||
Copyright (c) 2006-2024, assimp team
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
|
@ -60,7 +61,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
#include <functional>
|
||||
|
||||
namespace Assimp {
|
||||
namespace Assimp {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// std::plus-family operates on operands with identical types - we need to
|
||||
|
@ -230,8 +231,7 @@ private:
|
|||
|
||||
// ----------------------------------------------------------------------------
|
||||
/// This time binary arithmetic of v0 with a floating-point number
|
||||
template <template <typename, typename, typename> class op>
|
||||
static Vertex BinaryOp(const Vertex& v0, ai_real f) {
|
||||
template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, ai_real f) {
|
||||
// this is a heavy task for the compiler to optimize ... *pray*
|
||||
|
||||
Vertex res;
|
||||
|
@ -244,15 +244,14 @@ private:
|
|||
res.texcoords[i] = op<aiVector3D,ai_real,aiVector3D>()(v0.texcoords[i],f);
|
||||
}
|
||||
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
|
||||
res.colors[i] = op<aiColor4D,float, aiColor4D>()(v0.colors[i],f);
|
||||
res.colors[i] = op<aiColor4D,ai_real,aiColor4D>()(v0.colors[i],f);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
/** This time binary arithmetic of v0 with a floating-point number */
|
||||
template <template <typename, typename, typename> class op>
|
||||
static Vertex BinaryOp(ai_real f, const Vertex& v0) {
|
||||
template <template <typename, typename, typename> class op> static Vertex BinaryOp(ai_real f, const Vertex& v0) {
|
||||
// this is a heavy task for the compiler to optimize ... *pray*
|
||||
|
||||
Vertex res;
|
||||
|
@ -265,7 +264,7 @@ private:
|
|||
res.texcoords[i] = op<ai_real,aiVector3D,aiVector3D>()(f,v0.texcoords[i]);
|
||||
}
|
||||
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
|
||||
res.colors[i] = op<float, aiColor4D,aiColor4D>()(f,v0.colors[i]);
|
||||
res.colors[i] = op<ai_real,aiColor4D,aiColor4D>()(f,v0.colors[i]);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
|
|
@ -211,27 +211,21 @@ public:
|
|||
/// @return true, if the value can be read out.
|
||||
static inline bool getValueAsString(XmlNode &node, std::string &text);
|
||||
|
||||
/// @brief Will try to get the value of the node as a real.
|
||||
/// @param[in] node The node to search in.
|
||||
/// @param[out] v The value as a ai_real.
|
||||
/// @return true, if the value can be read out.
|
||||
static inline bool getValueAsReal(XmlNode &node, ai_real &v);
|
||||
|
||||
/// @brief Will try to get the value of the node as a float.
|
||||
/// @param[in] node The node to search in.
|
||||
/// @param[out]v The value as a float.
|
||||
/// @param[out] text The value as a float.
|
||||
/// @return true, if the value can be read out.
|
||||
static inline bool getValueAsFloat(XmlNode &node, float &v);
|
||||
static inline bool getValueAsFloat(XmlNode &node, ai_real &v);
|
||||
|
||||
/// @brief Will try to get the value of the node as an integer.
|
||||
/// @param[in] node The node to search in.
|
||||
/// @param[out] i The value as a int.
|
||||
/// @param[in] node The node to search in.
|
||||
/// @param[out] text The value as a int.
|
||||
/// @return true, if the value can be read out.
|
||||
static inline bool getValueAsInt(XmlNode &node, int &v);
|
||||
|
||||
/// @brief Will try to get the value of the node as an bool.
|
||||
/// @param[in] node The node to search in.
|
||||
/// @param[out] v The value as a bool.
|
||||
/// @param[in] node The node to search in.
|
||||
/// @param[out] text The value as a bool.
|
||||
/// @return true, if the value can be read out.
|
||||
static inline bool getValueAsBool(XmlNode &node, bool &v);
|
||||
|
||||
|
@ -460,19 +454,7 @@ inline bool TXmlParser<TNodeType>::getValueAsString(XmlNode &node, std::string &
|
|||
}
|
||||
|
||||
template <class TNodeType>
|
||||
inline bool TXmlParser<TNodeType>::getValueAsReal(XmlNode& node, ai_real& v) {
|
||||
if (node.empty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
v = node.text().as_float();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class TNodeType>
|
||||
inline bool TXmlParser<TNodeType>::getValueAsFloat(XmlNode &node, float &v) {
|
||||
inline bool TXmlParser<TNodeType>::getValueAsFloat(XmlNode &node, ai_real &v) {
|
||||
if (node.empty()) {
|
||||
return false;
|
||||
}
|
||||
|
|
|
@ -59,28 +59,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/**
|
||||
*/
|
||||
enum aiAnimInterpolation {
|
||||
/** */
|
||||
aiAnimInterpolation_Step,
|
||||
|
||||
/** */
|
||||
aiAnimInterpolation_Linear,
|
||||
|
||||
/** */
|
||||
aiAnimInterpolation_Spherical_Linear,
|
||||
|
||||
/** */
|
||||
aiAnimInterpolation_Cubic_Spline,
|
||||
|
||||
/** */
|
||||
#ifndef SWIG
|
||||
_aiAnimInterpolation_Force32Bit = INT_MAX
|
||||
#endif
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** A time-value pair specifying a certain 3D vector for the given time. */
|
||||
struct aiVectorKey {
|
||||
|
@ -90,18 +68,21 @@ struct aiVectorKey {
|
|||
/** The value of this key */
|
||||
C_STRUCT aiVector3D mValue;
|
||||
|
||||
/** The interpolation setting of this key */
|
||||
C_ENUM aiAnimInterpolation mInterpolation;
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
/// @brief The default constructor.
|
||||
aiVectorKey() AI_NO_EXCEPT
|
||||
: mTime(0.0), mValue(), mInterpolation(aiAnimInterpolation_Linear) {}
|
||||
: mTime(0.0),
|
||||
mValue() {
|
||||
// empty
|
||||
}
|
||||
|
||||
/// @brief Construction from a given time and key value.
|
||||
|
||||
aiVectorKey(double time, const aiVector3D &value) :
|
||||
mTime(time), mValue(value), mInterpolation(aiAnimInterpolation_Linear){}
|
||||
mTime(time), mValue(value) {
|
||||
// empty
|
||||
}
|
||||
|
||||
typedef aiVector3D elem_type;
|
||||
|
||||
|
@ -135,16 +116,16 @@ struct aiQuatKey {
|
|||
/** The value of this key */
|
||||
C_STRUCT aiQuaternion mValue;
|
||||
|
||||
/** The interpolation setting of this key */
|
||||
C_ENUM aiAnimInterpolation mInterpolation;
|
||||
|
||||
#ifdef __cplusplus
|
||||
aiQuatKey() AI_NO_EXCEPT
|
||||
: mTime(0.0), mValue(), mInterpolation(aiAnimInterpolation_Linear) {}
|
||||
: mTime(0.0),
|
||||
mValue() {
|
||||
// empty
|
||||
}
|
||||
|
||||
/** Construction from a given time and key value */
|
||||
aiQuatKey(double time, const aiQuaternion &value) :
|
||||
mTime(time), mValue(value), mInterpolation(aiAnimInterpolation_Linear) {}
|
||||
mTime(time), mValue(value) {}
|
||||
|
||||
typedef aiQuaternion elem_type;
|
||||
|
||||
|
|
|
@ -58,7 +58,6 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
struct aiScene;
|
||||
struct aiTexture;
|
||||
struct aiFileIO;
|
||||
|
||||
typedef void (*aiLogStreamCallback)(const char * /* message */, char * /* user */);
|
||||
|
@ -374,13 +373,6 @@ ASSIMP_API void aiGetMemoryRequirements(
|
|||
const C_STRUCT aiScene *pIn,
|
||||
C_STRUCT aiMemoryInfo *in);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Returns an embedded texture, or nullptr.
|
||||
* @param pIn Input asset.
|
||||
* @param filename Texture path extracted from aiGetMaterialString.
|
||||
*/
|
||||
ASSIMP_API const C_STRUCT aiTexture *aiGetEmbeddedTexture(const C_STRUCT aiScene *pIn, const char *filename);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Create an empty property store. Property stores are used to collect import
|
||||
* settings.
|
||||
|
@ -652,14 +644,14 @@ ASSIMP_API void aiVector2DivideByVector(
|
|||
/** Get the length of a 2D vector.
|
||||
* @return v Vector to evaluate
|
||||
*/
|
||||
ASSIMP_API ai_real aiVector2Length(
|
||||
ASSIMP_API float aiVector2Length(
|
||||
const C_STRUCT aiVector2D *v);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Get the squared length of a 2D vector.
|
||||
* @return v Vector to evaluate
|
||||
*/
|
||||
ASSIMP_API ai_real aiVector2SquareLength(
|
||||
ASSIMP_API float aiVector2SquareLength(
|
||||
const C_STRUCT aiVector2D *v);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
|
@ -675,7 +667,7 @@ ASSIMP_API void aiVector2Negate(
|
|||
* @param b Second vector
|
||||
* @return The dot product of vectors
|
||||
*/
|
||||
ASSIMP_API ai_real aiVector2DotProduct(
|
||||
ASSIMP_API float aiVector2DotProduct(
|
||||
const C_STRUCT aiVector2D *a,
|
||||
const C_STRUCT aiVector2D *b);
|
||||
|
||||
|
@ -782,14 +774,14 @@ ASSIMP_API void aiVector3DivideByVector(
|
|||
/** Get the length of a 3D vector.
|
||||
* @return v Vector to evaluate
|
||||
*/
|
||||
ASSIMP_API ai_real aiVector3Length(
|
||||
ASSIMP_API float aiVector3Length(
|
||||
const C_STRUCT aiVector3D *v);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Get the squared length of a 3D vector.
|
||||
* @return v Vector to evaluate
|
||||
*/
|
||||
ASSIMP_API ai_real aiVector3SquareLength(
|
||||
ASSIMP_API float aiVector3SquareLength(
|
||||
const C_STRUCT aiVector3D *v);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
|
@ -805,7 +797,7 @@ ASSIMP_API void aiVector3Negate(
|
|||
* @param b Second vector
|
||||
* @return The dot product of vectors
|
||||
*/
|
||||
ASSIMP_API ai_real aiVector3DotProduct(
|
||||
ASSIMP_API float aiVector3DotProduct(
|
||||
const C_STRUCT aiVector3D *a,
|
||||
const C_STRUCT aiVector3D *b);
|
||||
|
||||
|
@ -897,7 +889,7 @@ ASSIMP_API void aiMatrix3Inverse(
|
|||
/** Get the determinant of a 3x3 matrix.
|
||||
* @param mat Matrix to get the determinant from
|
||||
*/
|
||||
ASSIMP_API ai_real aiMatrix3Determinant(
|
||||
ASSIMP_API float aiMatrix3Determinant(
|
||||
const C_STRUCT aiMatrix3x3 *mat);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
|
@ -1007,7 +999,7 @@ ASSIMP_API void aiMatrix4Inverse(
|
|||
* @param mat Matrix to get the determinant from
|
||||
* @return The determinant of the matrix
|
||||
*/
|
||||
ASSIMP_API ai_real aiMatrix4Determinant(
|
||||
ASSIMP_API float aiMatrix4Determinant(
|
||||
const C_STRUCT aiMatrix4x4 *mat);
|
||||
|
||||
// --------------------------------------------------------------------------------
|
||||
|
|
|
@ -88,12 +88,12 @@ public:
|
|||
TReal r, g, b, a;
|
||||
}; // !struct aiColor4D
|
||||
|
||||
typedef aiColor4t<float> aiColor4D;
|
||||
typedef aiColor4t<ai_real> aiColor4D;
|
||||
|
||||
#else
|
||||
|
||||
struct aiColor4D {
|
||||
float r, g, b, a;
|
||||
ai_real r, g, b, a;
|
||||
};
|
||||
|
||||
#endif // __cplusplus
|
||||
|
|
|
@ -676,19 +676,6 @@ enum aiComponent
|
|||
#define AI_CONFIG_FBX_CONVERT_TO_M \
|
||||
"AI_CONFIG_FBX_CONVERT_TO_M"
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** @brief Set whether the FBX importer shall ignore the provided axis configuration
|
||||
*
|
||||
* If this property is set to true, the axis directions provided in the FBX file
|
||||
* will be ignored and the file will be loaded as is.
|
||||
*
|
||||
* Set to true for Assimp 5.3.x and earlier behavior
|
||||
* Equivalent to AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION
|
||||
* Property type: Bool. Default value: false.
|
||||
*/
|
||||
#define AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION \
|
||||
"AI_CONFIG_IMPORT_FBX_IGNORE_UP_DIRECTION"
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** @brief Will enable the skeleton struct to store bone data.
|
||||
*
|
||||
|
@ -737,12 +724,6 @@ enum aiComponent
|
|||
*/
|
||||
#define AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS "IMPORT_MDL_HL1_READ_ANIMATION_EVENTS"
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** @brief Set whether you want to convert the HS1 coordinate system in a special way.
|
||||
* The default value is true (S1)
|
||||
* Property type: bool
|
||||
*/
|
||||
#define AI_CONFIG_IMPORT_MDL_HL1_TRANSFORM_COORD_SYSTEM "TRANSFORM COORDSYSTEM FOR HS! MODELS"
|
||||
// ---------------------------------------------------------------------------
|
||||
/** @brief Set whether the MDL (HL1) importer will read blend controllers.
|
||||
* \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
|
||||
|
|
|
@ -49,16 +49,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#define AI_DEFINES_H_INC
|
||||
|
||||
#ifdef __GNUC__
|
||||
# pragma GCC system_header
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <assimp/config.h>
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* @brief Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific file format loader.
|
||||
*
|
||||
* The loader is be excluded from the
|
||||
/* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
|
||||
* file format loader. The loader is be excluded from the
|
||||
* build in this case. 'XX' stands for the most common file
|
||||
* extension of the file format. E.g.:
|
||||
* ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
|
||||
|
@ -78,33 +76,34 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_COMPRESSED_X
|
||||
# define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
#define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
#endif
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
|
||||
# define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
#define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
#endif
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
|
||||
# define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
# define ASSIMP_BUILD_NEED_UNZIP
|
||||
#define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
#define ASSIMP_BUILD_NEED_UNZIP
|
||||
#endif
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
|
||||
# define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
# define ASSIMP_BUILD_NEED_UNZIP
|
||||
#define ASSIMP_BUILD_NEED_Z_INFLATE
|
||||
#define ASSIMP_BUILD_NEED_UNZIP
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief We need those constants, workaround for any platforms where nobody defined them yet.
|
||||
*/
|
||||
// We need those constants, workaround for any platforms where nobody defined them yet
|
||||
#if (!defined SIZE_MAX)
|
||||
# define SIZE_MAX (~((size_t)0))
|
||||
#define SIZE_MAX (~((size_t)0))
|
||||
#endif
|
||||
|
||||
/*#if (!defined UINT_MAX)
|
||||
#define UINT_MAX (~((unsigned int)0))
|
||||
#endif*/
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/** @brief Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
|
||||
*
|
||||
/* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
|
||||
* post processing step. This is the current list of process names ('XX'):
|
||||
* CALCTANGENTS
|
||||
* JOINVERTICES
|
||||
|
@ -135,50 +134,46 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
* OPTIMIZEGRAPH
|
||||
* GENENTITYMESHES
|
||||
* FIXTEXTUREPATHS
|
||||
* GENBOUNDINGBOXES
|
||||
*/
|
||||
* GENBOUNDINGBOXES */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef _WIN32
|
||||
#undef ASSIMP_API
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
#ifdef ASSIMP_BUILD_DLL_EXPORT
|
||||
#define ASSIMP_API __declspec(dllexport)
|
||||
#define ASSIMP_API_WINONLY __declspec(dllexport)
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/** @brief Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library
|
||||
*
|
||||
* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
|
||||
* an external DLL under Windows. Default is static linkage.
|
||||
*/
|
||||
/* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
|
||||
* an external DLL under Windows. Default is static linkage. */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
#ifdef _WIN32
|
||||
# undef ASSIMP_API
|
||||
# ifdef ASSIMP_BUILD_DLL_EXPORT
|
||||
# define ASSIMP_API __declspec(dllexport)
|
||||
# define ASSIMP_API_WINONLY __declspec(dllexport)
|
||||
# elif (defined ASSIMP_DLL)
|
||||
# define ASSIMP_API __declspec(dllimport)
|
||||
# define ASSIMP_API_WINONLY __declspec(dllimport)
|
||||
# else
|
||||
# define ASSIMP_API
|
||||
# define ASSIMP_API_WINONLY
|
||||
# endif
|
||||
#else
|
||||
# define ASSIMP_API __attribute__((visibility("default")))
|
||||
# define ASSIMP_API_WINONLY
|
||||
#elif (defined ASSIMP_DLL)
|
||||
#define ASSIMP_API __declspec(dllimport)
|
||||
#define ASSIMP_API_WINONLY __declspec(dllimport)
|
||||
#else
|
||||
#define ASSIMP_API
|
||||
#define ASSIMP_API_WINONLY
|
||||
#endif
|
||||
#elif defined(SWIG)
|
||||
/* Do nothing, the relevant defines are all in AssimpSwigPort.i */
|
||||
#else
|
||||
#define ASSIMP_API __attribute__((visibility("default")))
|
||||
#define ASSIMP_API_WINONLY
|
||||
#endif // _WIN32
|
||||
|
||||
/**
|
||||
* @brief Helper macros
|
||||
*
|
||||
* @def AI_FORCE_INLINE
|
||||
* @brief Force the compiler to inline a function, if possible
|
||||
*
|
||||
* @def AI_WONT_RETURN
|
||||
* @brief Tells the compiler that a function never returns.
|
||||
*
|
||||
* Used in code analysis to skip dead paths (e.g. after an assertion evaluated to false).
|
||||
*/
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable : 4521 4512 4714 4127 4351 4510)
|
||||
#ifdef ASSIMP_BUILD_DLL_EXPORT
|
||||
#pragma warning(disable : 4251)
|
||||
#endif
|
||||
/* Force the compiler to inline a function, if possible */
|
||||
#define AI_FORCE_INLINE inline
|
||||
|
||||
/* Tells the compiler that a function never returns. Used in code analysis
|
||||
* to skip dead paths (e.g. after an assertion evaluated to false). */
|
||||
#define AI_WONT_RETURN __declspec(noreturn)
|
||||
#elif defined(SWIG)
|
||||
/* Do nothing, the relevant defines are all in AssimpSwigPort.i */
|
||||
|
@ -201,14 +196,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
#ifdef __cplusplus
|
||||
/* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
|
||||
* in doxydocs. */
|
||||
* in doxydocs.
|
||||
*/
|
||||
#define C_STRUCT
|
||||
#define C_ENUM
|
||||
#else
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
|
||||
* is defined by Doxygen's preprocessor. The corresponding
|
||||
* entries in the DOXYFILE are: */
|
||||
* is defined by Doxygen's preprocessor. The corresponding
|
||||
* entries in the DOXYFILE are: */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
#if 0
|
||||
ENABLE_PREPROCESSING = YES
|
||||
|
@ -228,36 +224,34 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
* to typedef all structs/enums. */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
#if (defined ASSIMP_DOXYGEN_BUILD)
|
||||
# define C_STRUCT
|
||||
# define C_ENUM
|
||||
#define C_STRUCT
|
||||
#define C_ENUM
|
||||
#else
|
||||
# define C_STRUCT struct
|
||||
# define C_ENUM enum
|
||||
#define C_STRUCT struct
|
||||
#define C_ENUM enum
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if (defined(__BORLANDC__) || defined(__BCPLUSPLUS__))
|
||||
# error Currently, Borland is unsupported. Feel free to port Assimp.
|
||||
#error Currently, Borland is unsupported. Feel free to port Assimp.
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
|
||||
* without threading support. The library doesn't utilize
|
||||
* threads then and is itself not threadsafe.
|
||||
*/
|
||||
/* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
|
||||
* without threading support. The library doesn't utilize
|
||||
* threads then and is itself not threadsafe. */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
#ifndef ASSIMP_BUILD_SINGLETHREADED
|
||||
# define ASSIMP_BUILD_SINGLETHREADED
|
||||
#define ASSIMP_BUILD_SINGLETHREADED
|
||||
#endif
|
||||
|
||||
#if defined(_DEBUG) || !defined(NDEBUG)
|
||||
# define ASSIMP_BUILD_DEBUG
|
||||
#define ASSIMP_BUILD_DEBUG
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/* Define ASSIMP_DOUBLE_PRECISION to compile assimp
|
||||
* with double precision support (64-bit). */
|
||||
* with double precision support (64-bit). */
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef ASSIMP_DOUBLE_PRECISION
|
||||
|
@ -298,74 +292,55 @@ typedef unsigned int ai_uint;
|
|||
#ifdef __cplusplus
|
||||
constexpr ai_real ai_epsilon = (ai_real) 1e-6;
|
||||
#else
|
||||
# define ai_epsilon ((ai_real)1e-6)
|
||||
#define ai_epsilon ((ai_real)1e-6)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Support for big-endian builds
|
||||
*
|
||||
* This will check which byte ordering is used on the target architecture.
|
||||
*/
|
||||
/* Support for big-endian builds */
|
||||
#if defined(__BYTE_ORDER__)
|
||||
# if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
|
||||
# if !defined(__BIG_ENDIAN__)
|
||||
# define __BIG_ENDIAN__
|
||||
# endif
|
||||
# else /* little endian */
|
||||
# if defined(__BIG_ENDIAN__)
|
||||
# undef __BIG_ENDIAN__
|
||||
# endif
|
||||
# endif
|
||||
#if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
|
||||
#if !defined(__BIG_ENDIAN__)
|
||||
#define __BIG_ENDIAN__
|
||||
#endif
|
||||
#else /* little endian */
|
||||
#if defined(__BIG_ENDIAN__)
|
||||
#undef __BIG_ENDIAN__
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#if defined(__BIG_ENDIAN__)
|
||||
# define AI_BUILD_BIG_ENDIAN
|
||||
#define AI_BUILD_BIG_ENDIAN
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief To avoid running out of memory
|
||||
*
|
||||
* To avoid running out of memory
|
||||
* This can be adjusted for specific use cases
|
||||
* It's NOT a total limit, just a limit for individual allocations
|
||||
*/
|
||||
#define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
|
||||
|
||||
#ifndef _MSC_VER
|
||||
# if __cplusplus >= 201103L // C++11
|
||||
# define AI_NO_EXCEPT noexcept
|
||||
# else
|
||||
# define AI_NO_EXCEPT
|
||||
# endif
|
||||
#if __cplusplus >= 201103L // C++11
|
||||
#define AI_NO_EXCEPT noexcept
|
||||
#else
|
||||
# if (_MSC_VER >= 1915)
|
||||
# define AI_NO_EXCEPT noexcept
|
||||
# else
|
||||
# define AI_NO_EXCEPT
|
||||
# endif
|
||||
#define AI_NO_EXCEPT
|
||||
#endif
|
||||
#else
|
||||
#if (_MSC_VER >= 1915)
|
||||
#define AI_NO_EXCEPT noexcept
|
||||
#else
|
||||
#define AI_NO_EXCEPT
|
||||
#endif
|
||||
#endif // _MSC_VER
|
||||
|
||||
/**
|
||||
* @brief Helper macro to set a pointer to NULL in debug builds
|
||||
* Helper macro to set a pointer to NULL in debug builds
|
||||
*/
|
||||
#if (defined ASSIMP_BUILD_DEBUG)
|
||||
# define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
|
||||
#define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
|
||||
#else
|
||||
# define AI_DEBUG_INVALIDATE_PTR(x)
|
||||
#define AI_DEBUG_INVALIDATE_PTR(x)
|
||||
#endif
|
||||
|
||||
#define AI_COUNT_OF(X) (sizeof(X) / sizeof((X)[0]))
|
||||
|
||||
/**
|
||||
* @brief Will mark functions or classes as deprecated.
|
||||
*
|
||||
* Deprecation means that we will remove this function, class or methods in the next m
|
||||
*/
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
# define AI_DEPRECATED __attribute__((deprecated))
|
||||
#elif defined(_MSC_VER)
|
||||
# define AI_DEPRECATED __declspec(deprecated)
|
||||
#else
|
||||
# pragma message("WARNING: You need to implement DEPRECATED for this compiler")
|
||||
# define AI_DEPRECATED
|
||||
#endif
|
||||
|
||||
#endif // !! AI_DEFINES_H_INC
|
||||
#endif // !! AI_DEFINES_H_INC
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue