v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into issue_3398

pull/4029/head
Kim Kulling 2021-08-28 13:56:50 +02:00 committed by GitHub
parent 69051bbc2c 6841397798
commit df739f00dd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
210 changed files with 1421 additions and 1329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
CMakeLists.txt
View File

@ -44,7 +44,7 @@ CMAKE_MINIMUM_REQUIRED( VERSION 3.10 )
option(ASSIMP_HUNTER_ENABLED "Enable Hunter package manager support" OFF) option(ASSIMP_HUNTER_ENABLED "Enable Hunter package manager support" OFF)
IF(ASSIMP_HUNTER_ENABLED) IF(ASSIMP_HUNTER_ENABLED)
include("cmake/HunterGate.cmake") include("cmake-modules/HunterGate.cmake")
HunterGate( HunterGate(
URL "https://github.com/cpp-pm/hunter/archive/v0.23.311.tar.gz" URL "https://github.com/cpp-pm/hunter/archive/v0.23.311.tar.gz"
SHA1 "1a82b9b73055879181cb1466b2ab5d48ee8ae410" SHA1 "1a82b9b73055879181cb1466b2ab5d48ee8ae410"
@ -135,11 +135,11 @@ IF ( WIN32 )
# Use subset of Windows.h # Use subset of Windows.h
ADD_DEFINITIONS( -DWIN32_LEAN_AND_MEAN ) ADD_DEFINITIONS( -DWIN32_LEAN_AND_MEAN )
OPTION ( ASSIMP_BUILD_ASSIMP_VIEW
"If the Assimp view tool is built. (requires DirectX)"
OFF )
IF(MSVC) IF(MSVC)
OPTION ( ASSIMP_BUILD_ASSIMP_VIEW
"If the Assimp view tool is built. (requires DirectX)"
OFF )
OPTION( ASSIMP_INSTALL_PDB OPTION( ASSIMP_INSTALL_PDB
"Install MSVC debug files." "Install MSVC debug files."
ON ) ON )
@ -397,14 +397,14 @@ set(GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
IF(ASSIMP_HUNTER_ENABLED) IF(ASSIMP_HUNTER_ENABLED)
set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}") set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}")
set(CMAKE_CONFIG_TEMPLATE_FILE "cmake/assimp-hunter-config.cmake.in") set(CMAKE_CONFIG_TEMPLATE_FILE "cmake-modules/assimp-hunter-config.cmake.in")
set(NAMESPACE "${PROJECT_NAME}::") set(NAMESPACE "${PROJECT_NAME}::")
set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets") set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake") set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake") set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake")
ELSE() ELSE()
set(CONFIG_INSTALL_DIR "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}") set(CONFIG_INSTALL_DIR "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}")
set(CMAKE_CONFIG_TEMPLATE_FILE "cmake/assimp-plain-config.cmake.in") set(CMAKE_CONFIG_TEMPLATE_FILE "cmake-modules/assimp-plain-config.cmake.in")
string(TOLOWER ${PROJECT_NAME} PROJECT_NAME_LOWERCASE) string(TOLOWER ${PROJECT_NAME} PROJECT_NAME_LOWERCASE)
set(NAMESPACE "${PROJECT_NAME_LOWERCASE}::") set(NAMESPACE "${PROJECT_NAME_LOWERCASE}::")
set(TARGETS_EXPORT_NAME "${PROJECT_NAME_LOWERCASE}Targets") set(TARGETS_EXPORT_NAME "${PROJECT_NAME_LOWERCASE}Targets")

17
cmake-modules/FindIrrXML.cmake
View File

@ -1,17 +0,0 @@
# Find IrrXMl from irrlicht project
#
# Find LibIrrXML headers and library
#
# IRRXML_FOUND - IrrXML found
# IRRXML_INCLUDE_DIR - Headers location
# IRRXML_LIBRARY - IrrXML main library
find_path(IRRXML_INCLUDE_DIR irrXML.h
PATH_SUFFIXES include/irrlicht include/irrxml)
find_library(IRRXML_LIBRARY IrrXML)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(IrrXML REQUIRED_VARS IRRXML_INCLUDE_DIR IRRXML_LIBRARY)
mark_as_advanced(IRRXML_INCLUDE_DIR IRRXML_LIBRARY)

0
cmake/HunterGate.cmake → cmake-modules/HunterGate.cmake
View File

19
cmake-modules/assimp-hunter-config.cmake.in 100644
View File

@ -0,0 +1,19 @@
@PACKAGE_INIT@
find_package(RapidJSON CONFIG REQUIRED)
find_package(ZLIB CONFIG REQUIRED)
find_package(utf8cpp CONFIG REQUIRED)
find_package(minizip CONFIG REQUIRED)
find_package(openddlparser CONFIG REQUIRED)
find_package(poly2tri CONFIG REQUIRED)
find_package(polyclipping CONFIG REQUIRED)
find_package(zip CONFIG REQUIRED)
find_package(pugixml CONFIG REQUIRED)
find_package(stb CONFIG REQUIRED)
if(@ASSIMP_BUILD_DRACO@)
find_package(draco CONFIG REQUIRED)
endif()
include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
check_required_components("@PROJECT_NAME@")

0
cmake/assimp-plain-config.cmake.in → cmake-modules/assimp-plain-config.cmake.in
View File

19
cmake/assimp-hunter-config.cmake.in
View File

@ -1,19 +0,0 @@
@PACKAGE_INIT@
find_package(RapidJSON CONFIG REQUIRED)
find_package(ZLIB CONFIG REQUIRED)
find_package(utf8cpp CONFIG REQUIRED)
find_package(minizip CONFIG REQUIRED)
find_package(openddlparser CONFIG REQUIRED)
find_package(poly2tri CONFIG REQUIRED)
find_package(polyclipping CONFIG REQUIRED)
find_package(zip CONFIG REQUIRED)
find_package(pugixml CONFIG REQUIRED)
find_package(stb CONFIG REQUIRED)
if(@ASSIMP_BUILD_DRACO@)
find_package(draco CONFIG REQUIRED)
endif()
include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
check_required_components("@PROJECT_NAME@")

2
code/AssetLib/3DS/3DSExporter.cpp
View File

@ -291,7 +291,7 @@ void Discreet3DSExporter::WriteMaterials() {
ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_SPECULAR); ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_SPECULAR);
WriteColor(color); WriteColor(color);
} }
if (mat.Get(AI_MATKEY_COLOR_AMBIENT, color) == AI_SUCCESS) { if (mat.Get(AI_MATKEY_COLOR_AMBIENT, color) == AI_SUCCESS) {
ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_AMBIENT); ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_AMBIENT);
WriteColor(color); WriteColor(color);

2
code/AssetLib/3MF/3MFXmlTags.h
View File

@ -111,7 +111,7 @@ namespace XmlTag {
const char* const PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture"; const char* const PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
const char* const PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"; const char* const PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
const char* const PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail"; const char* const PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
} }
} // Namespace D3MF } // Namespace D3MF
} // Namespace Assimp } // Namespace Assimp

2
code/AssetLib/AMF/AMFImporter.cpp
View File

@ -303,7 +303,7 @@ void AMFImporter::ParseNode_Root() {
} }
XmlNode node = *root; XmlNode node = *root;
mUnit = ai_tolower(std::string(node.attribute("unit").as_string())); mUnit = ai_tolower(std::string(node.attribute("unit").as_string()));
mVersion = node.attribute("version").as_string(); mVersion = node.attribute("version").as_string();
// Read attributes for node <amf>. // Read attributes for node <amf>.

6
code/AssetLib/AMF/AMFImporter_Geometry.cpp
View File

@ -75,7 +75,7 @@ void AMFImporter::ParseNode_Mesh(XmlNode &node) {
found_volumes = true; found_volumes = true;
} }
ParseHelper_Node_Exit(); ParseHelper_Node_Exit();
} }
if (!found_verts && !found_volumes) { if (!found_verts && !found_volumes) {
mNodeElement_Cur->Child.push_back(ne); mNodeElement_Cur->Child.push_back(ne);
@ -199,9 +199,9 @@ void AMFImporter::ParseNode_Volume(XmlNode &node) {
// Read attributes for node <color>. // Read attributes for node <color>.
// and assign read data // and assign read data
((AMFVolume *)ne)->MaterialID = node.attribute("materialid").as_string(); ((AMFVolume *)ne)->MaterialID = node.attribute("materialid").as_string();
((AMFVolume *)ne)->Type = type; ((AMFVolume *)ne)->Type = type;
// Check for child nodes // Check for child nodes
bool col_read = false; bool col_read = false;

6
code/AssetLib/AMF/AMFImporter_Postprocess.cpp
View File

@ -69,7 +69,7 @@ aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*
} }
tcol = Color->Color; tcol = Color->Color;
// Check if default color must be used // Check if default color must be used
if ((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0)) { if ((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0)) {
tcol.r = 0.5f; tcol.r = 0.5f;
@ -99,10 +99,10 @@ void AMFImporter::PostprocessHelper_CreateMeshDataArray(const AMFMesh &nodeEleme
} }
// all coordinates stored as child and we need to reserve space for future push_back's. // all coordinates stored as child and we need to reserve space for future push_back's.
vertexCoordinateArray.reserve(vn->Child.size()); vertexCoordinateArray.reserve(vn->Child.size());
// colors count equal vertices count. // colors count equal vertices count.
pVertexColorArray.resize(vn->Child.size()); pVertexColorArray.resize(vn->Child.size());
col_idx = 0; col_idx = 0;
// Inside vertices collect all data and place to arrays // Inside vertices collect all data and place to arrays

2
code/AssetLib/Assbin/AssbinFileWriter.cpp
View File

@ -172,7 +172,7 @@ inline size_t Write<aiQuaternion>(IOStream *stream, const aiQuaternion &v) {
t += Write<float>(stream, v.z); t += Write<float>(stream, v.z);
ai_assert(t == 16); ai_assert(t == 16);
return 16; return t;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------

8
code/AssetLib/Assjson/mesh_splitter.cpp
View File

@ -110,7 +110,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
// we need to split this mesh into sub meshes. Estimate submesh size // we need to split this mesh into sub meshes. Estimate submesh size
const unsigned int sub_meshes = (in_mesh->mNumVertices / LIMIT) + 1; const unsigned int sub_meshes = (in_mesh->mNumVertices / LIMIT) + 1;
// create a std::vector<unsigned int> to remember which vertices have already // create a std::vector<unsigned int> to remember which vertices have already
// been copied and to which position (i.e. output index) // been copied and to which position (i.e. output index)
std::vector<unsigned int> was_copied_to; std::vector<unsigned int> was_copied_to;
was_copied_to.resize(in_mesh->mNumVertices,WAS_NOT_COPIED); was_copied_to.resize(in_mesh->mNumVertices,WAS_NOT_COPIED);
@ -125,7 +125,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
while (true) { while (true) {
const unsigned int out_vertex_index = LIMIT; const unsigned int out_vertex_index = LIMIT;
aiMesh* out_mesh = new aiMesh(); aiMesh* out_mesh = new aiMesh();
out_mesh->mNumVertices = 0; out_mesh->mNumVertices = 0;
out_mesh->mMaterialIndex = in_mesh->mMaterialIndex; out_mesh->mMaterialIndex = in_mesh->mMaterialIndex;
@ -179,7 +179,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
// check whether we do already have this vertex // check whether we do already have this vertex
if (WAS_NOT_COPIED == was_copied_to[index]) { if (WAS_NOT_COPIED == was_copied_to[index]) {
iNeed++; iNeed++;
} }
} }
if (out_mesh->mNumVertices + iNeed > out_vertex_index) { if (out_mesh->mNumVertices + iNeed > out_vertex_index) {
@ -240,7 +240,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
out_mesh->mTextureCoords[c][out_mesh->mNumVertices] = in_mesh->mTextureCoords[c][index]; out_mesh->mTextureCoords[c][out_mesh->mNumVertices] = in_mesh->mTextureCoords[c][index];
} }
} }
// vertex colors // vertex colors
for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) { for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
if (in_mesh->HasVertexColors( c)) { if (in_mesh->HasVertexColors( c)) {
out_mesh->mColors[c][out_mesh->mNumVertices] = in_mesh->mColors[c][index]; out_mesh->mColors[c][out_mesh->mNumVertices] = in_mesh->mColors[c][index];

6
code/AssetLib/Assjson/mesh_splitter.h
View File

@ -22,13 +22,13 @@ struct aiNode;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Splits meshes of unique vertices into meshes with no more vertices than /** Splits meshes of unique vertices into meshes with no more vertices than
* a given, configurable threshold value. * a given, configurable threshold value.
*/ */
class MeshSplitter class MeshSplitter
{ {
public: public:
void SetLimit(unsigned int l) { void SetLimit(unsigned int l) {
LIMIT = l; LIMIT = l;
} }

2
code/AssetLib/Assxml/AssxmlExporter.cpp
View File

@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
#include <assimp/Exporter.hpp> #include <assimp/Exporter.hpp>
namespace Assimp { namespace Assimp {
void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
{ {

18
code/AssetLib/Blender/BlenderModifier.h
View File

@ -52,9 +52,9 @@ namespace Assimp {
namespace Blender { namespace Blender {
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
/** /**
* Dummy base class for all blender modifiers. Modifiers are reused between imports, so * Dummy base class for all blender modifiers. Modifiers are reused between imports, so
* they should be stateless and not try to cache model data. * they should be stateless and not try to cache model data.
*/ */
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
class BlenderModifier { class BlenderModifier {
@ -67,7 +67,7 @@ public:
} }
// -------------------- // --------------------
/** /**
* Check if *this* modifier is active, given a ModifierData& block. * Check if *this* modifier is active, given a ModifierData& block.
*/ */
virtual bool IsActive( const ModifierData& /*modin*/) { virtual bool IsActive( const ModifierData& /*modin*/) {
@ -75,10 +75,10 @@ public:
} }
// -------------------- // --------------------
/** /**
* Apply the modifier to a given output node. The original data used * Apply the modifier to a given output node. The original data used
* to construct the node is given as well. Not called unless IsActive() * to construct the node is given as well. Not called unless IsActive()
* was called and gave positive response. * was called and gave positive response.
*/ */
virtual void DoIt(aiNode& /*out*/, virtual void DoIt(aiNode& /*out*/,
ConversionData& /*conv_data*/, ConversionData& /*conv_data*/,
@ -92,8 +92,8 @@ public:
}; };
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
/** /**
* Manage all known modifiers and instance and apply them if necessary * Manage all known modifiers and instance and apply them if necessary
*/ */
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
class BlenderModifierShowcase { class BlenderModifierShowcase {
@ -113,8 +113,8 @@ private:
// MODIFIERS ///////////////////////////////////////////////////////////////////////////////// // MODIFIERS /////////////////////////////////////////////////////////////////////////////////
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
/** /**
* Mirror modifier. Status: implemented. * Mirror modifier. Status: implemented.
*/ */
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
class BlenderModifier_Mirror : public BlenderModifier { class BlenderModifier_Mirror : public BlenderModifier {

6
code/AssetLib/C4D/C4DImporter.cpp
View File

@ -146,8 +146,14 @@ void C4DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
ThrowException("failed to read document " + pFile); ThrowException("failed to read document " + pFile);
} }
// Generate the root-node
pScene->mRootNode = new aiNode("<C4DRoot>"); pScene->mRootNode = new aiNode("<C4DRoot>");
// convert left-handed to right-handed
pScene->mRootNode->mTransformation.a1 = 0.01f;
pScene->mRootNode->mTransformation.b2 = 0.01f;
pScene->mRootNode->mTransformation.c3 = -0.01f;
// first convert all materials // first convert all materials
ReadMaterials(doc->GetFirstMaterial()); ReadMaterials(doc->GetFirstMaterial());

2
code/AssetLib/COB/COBLoader.cpp
View File

@ -884,7 +884,7 @@ void COBImporter::ReadBinaryFile(Scene &out, StreamReaderLE *reader) {
std::string type; std::string type;
type += reader->GetI1(); type += reader->GetI1();
type += reader->GetI1(); type += reader->GetI1();
type += reader->GetI1(); type += reader->GetI1();
type += reader->GetI1(); type += reader->GetI1();
ChunkInfo nfo; ChunkInfo nfo;

2
code/AssetLib/COB/COBLoader.h
View File

@ -77,7 +77,7 @@ class COBImporter : public BaseImporter
public: public:
COBImporter(); COBImporter();
~COBImporter(); ~COBImporter();
// -------------------- // --------------------
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
bool checkSig) const; bool checkSig) const;

6
code/AssetLib/Collada/ColladaLoader.cpp
View File

@ -620,6 +620,10 @@ aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrc
dstMesh->mName = pSrcMesh->mId; dstMesh->mName = pSrcMesh->mId;
} }
if (pSrcMesh->mPositions.empty()) {
return dstMesh.release();
}
// count the vertices addressed by its faces // count the vertices addressed by its faces
const size_t numVertices = std::accumulate(pSrcMesh->mFaceSize.begin() + pStartFace, const size_t numVertices = std::accumulate(pSrcMesh->mFaceSize.begin() + pStartFace,
pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0)); pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0));
@ -1672,7 +1676,7 @@ void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/)
const Material &material = matIt->second; const Material &material = matIt->second;
// a material is only a reference to an effect // a material is only a reference to an effect
ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect); ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect);
if (effIt == pParser.mEffectLibrary.end()) if (effIt == pParser.mEffectLibrary.end())
continue; continue;
Effect &effect = effIt->second; Effect &effect = effIt->second;

4
code/AssetLib/Collada/ColladaParser.cpp
View File

@ -231,11 +231,7 @@ void ColladaParser::UriDecodePath(aiString &ss) {
// Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes... // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
// I need to filter it without destroying linux paths starting with "/somewhere" // I need to filter it without destroying linux paths starting with "/somewhere"
#if defined(_MSC_VER)
if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') { if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
#else
if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
#endif
--ss.length; --ss.length;
::memmove(ss.data, ss.data + 1, ss.length); ::memmove(ss.data, ss.data + 1, ss.length);
ss.data[ss.length] = 0; ss.data[ss.length] = 0;

2
code/AssetLib/DXF/DXFLoader.cpp
View File

@ -547,7 +547,7 @@ void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
++reader; ++reader;
} }
ASSIMP_LOG_VERBOSE_DEBUG( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(), ASSIMP_LOG_VERBOSE_DEBUG( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(),
" inserted blocks in ENTITIES" ); " inserted blocks in ENTITIES" );
} }

2
code/AssetLib/DXF/DXFLoader.h
View File

@ -63,7 +63,7 @@ namespace DXF {
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** /**
* @brief DXF importer implementation. * @brief DXF importer implementation.
*/ */
class DXFImporter : public BaseImporter { class DXFImporter : public BaseImporter {

8
code/AssetLib/FBX/FBXConverter.cpp
View File

@ -862,7 +862,7 @@ bool FBXConverter::GenerateTransformationNodeChain(const Model &model, const std
output_nodes.push_back(std::move(nd)); output_nodes.push_back(std::move(nd));
return false; return false;
} }
void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) { void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) {
const PropertyTable &props = model.Props(); const PropertyTable &props = model.Props();
DirectPropertyMap unparsedProperties = props.GetUnparsedProperties(); DirectPropertyMap unparsedProperties = props.GetUnparsedProperties();
@ -2131,7 +2131,7 @@ void FBXConverter::SetShadingPropertiesCommon(aiMaterial *out_mat, const Propert
if (ok) { if (ok) {
out_mat->AddProperty(&Emissive, 1, AI_MATKEY_COLOR_EMISSIVE); out_mat->AddProperty(&Emissive, 1, AI_MATKEY_COLOR_EMISSIVE);
} else { } else {
const aiColor3D &emissiveColor = GetColorPropertyFromMaterial(props, "Maya|emissive", ok); const aiColor3D &emissiveColor = GetColorProperty(props, "Maya|emissive", ok);
if (ok) { if (ok) {
out_mat->AddProperty(&emissiveColor, 1, AI_MATKEY_COLOR_EMISSIVE); out_mat->AddProperty(&emissiveColor, 1, AI_MATKEY_COLOR_EMISSIVE);
} }
@ -2218,7 +2218,7 @@ void FBXConverter::SetShadingPropertiesCommon(aiMaterial *out_mat, const Propert
} }
// PBR material information // PBR material information
const aiColor3D &baseColor = GetColorPropertyFromMaterial(props, "Maya|base_color", ok); const aiColor3D &baseColor = GetColorProperty(props, "Maya|base_color", ok);
if (ok) { if (ok) {
out_mat->AddProperty(&baseColor, 1, AI_MATKEY_BASE_COLOR); out_mat->AddProperty(&baseColor, 1, AI_MATKEY_BASE_COLOR);
} }
@ -3572,7 +3572,7 @@ void FBXConverter::ConvertOrphanedEmbeddedTextures() {
if (texture->Media() && texture->Media()->ContentLength() > 0) { if (texture->Media() && texture->Media()->ContentLength() > 0) {
realTexture = texture; realTexture = texture;
} }
} }
} }
} catch (...) { } catch (...) {
// do nothing // do nothing

4
code/AssetLib/FBX/FBXConverter.h
View File

@ -76,7 +76,7 @@ namespace Assimp {
namespace FBX { namespace FBX {
class Document; class Document;
/** /**
* Convert a FBX #Document to #aiScene * Convert a FBX #Document to #aiScene
* @param out Empty scene to be populated * @param out Empty scene to be populated
* @param doc Parsed FBX document * @param doc Parsed FBX document
@ -182,7 +182,7 @@ private:
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void ConvertModel(const Model &model, aiNode *parent, aiNode *root_node, void ConvertModel(const Model &model, aiNode *parent, aiNode *root_node,
const aiMatrix4x4 &absolute_transform); const aiMatrix4x4 &absolute_transform);
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// MeshGeometry -> aiMesh, return mesh index + 1 or 0 if the conversion failed // MeshGeometry -> aiMesh, return mesh index + 1 or 0 if the conversion failed
std::vector<unsigned int> std::vector<unsigned int>

2
code/AssetLib/FBX/FBXDocument.cpp
View File

@ -635,7 +635,7 @@ std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t source, std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t source,
const char* const* classnames, size_t count) const const char* const* classnames, size_t count) const
{ {
return GetConnectionsSequenced(source, true, ConnectionsBySource(),classnames, count); return GetConnectionsSequenced(source, true, ConnectionsBySource(),classnames, count);

2
code/AssetLib/FBX/FBXExportNode.h
View File

@ -60,7 +60,7 @@ namespace FBX {
} }
class FBX::Node { class FBX::Node {
public: public:
// TODO: accessors // TODO: accessors
std::string name; // node name std::string name; // node name
std::vector<FBX::FBXExportProperty> properties; // node properties std::vector<FBX::FBXExportProperty> properties; // node properties

12
code/AssetLib/FBX/FBXExporter.cpp
View File

@ -498,7 +498,7 @@ void FBXExporter::WriteDocuments ()
if (!binary) { if (!binary) {
WriteAsciiSectionHeader("Documents Description"); WriteAsciiSectionHeader("Documents Description");
} }
// not sure what the use of multiple documents would be, // not sure what the use of multiple documents would be,
// or whether any end-application supports it // or whether any end-application supports it
FBX::Node docs("Documents"); FBX::Node docs("Documents");
@ -1258,7 +1258,7 @@ void FBXExporter::WriteObjects ()
indent = 2; indent = 2;
vertexcolors.End(outstream, binary, indent, true); vertexcolors.End(outstream, binary, indent, true);
} }
// uvs, if any // uvs, if any
for (size_t uvi = 0; uvi < m->GetNumUVChannels(); ++uvi) { for (size_t uvi = 0; uvi < m->GetNumUVChannels(); ++uvi) {
if (m->mNumUVComponents[uvi] > 2) { if (m->mNumUVComponents[uvi] > 2) {
@ -1751,7 +1751,7 @@ void FBXExporter::WriteObjects ()
bsnode.AddProperty(blendshape_uid); bsnode.AddProperty(blendshape_uid);
bsnode.AddProperty(blendshape_name + FBX::SEPARATOR + "Blendshape"); bsnode.AddProperty(blendshape_name + FBX::SEPARATOR + "Blendshape");
bsnode.AddProperty("Shape"); bsnode.AddProperty("Shape");
bsnode.AddChild("Version", int32_t(100)); bsnode.AddChild("Version", int32_t(100));
bsnode.Begin(outstream, binary, indent); bsnode.Begin(outstream, binary, indent);
bsnode.DumpProperties(outstream, binary, indent); bsnode.DumpProperties(outstream, binary, indent);
bsnode.EndProperties(outstream, binary, indent); bsnode.EndProperties(outstream, binary, indent);
@ -1877,7 +1877,7 @@ void FBXExporter::WriteObjects ()
// at the same time we can build a list of all the skeleton nodes, // at the same time we can build a list of all the skeleton nodes,
// which will be used later to mark them as type "limbNode". // which will be used later to mark them as type "limbNode".
std::unordered_set<const aiNode*> limbnodes; std::unordered_set<const aiNode*> limbnodes;
//actual bone nodes in fbx, without parenting-up //actual bone nodes in fbx, without parenting-up
std::unordered_set<std::string> setAllBoneNamesInScene; std::unordered_set<std::string> setAllBoneNamesInScene;
for(unsigned int m = 0; m < mScene->mNumMeshes; ++ m) for(unsigned int m = 0; m < mScene->mNumMeshes; ++ m)
@ -1887,7 +1887,7 @@ void FBXExporter::WriteObjects ()
setAllBoneNamesInScene.insert(pMesh->mBones[b]->mName.data); setAllBoneNamesInScene.insert(pMesh->mBones[b]->mName.data);
} }
aiMatrix4x4 mxTransIdentity; aiMatrix4x4 mxTransIdentity;
// and a map of nodes by bone name, as finding them is annoying. // and a map of nodes by bone name, as finding them is annoying.
std::map<std::string,aiNode*> node_by_bone; std::map<std::string,aiNode*> node_by_bone;
for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) { for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) {
@ -1956,7 +1956,7 @@ void FBXExporter::WriteObjects ()
} }
if (end) { break; } if (end) { break; }
} }
// if it was the skeleton root we can finish here // if it was the skeleton root we can finish here
if (end) { break; } if (end) { break; }
} }

8
code/AssetLib/FBX/FBXMaterial.cpp
View File

@ -142,8 +142,8 @@ Material::~Material() {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name) : Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
Object(id,element,name), Object(id,element,name),
uvScaling(1.0f,1.0f), uvScaling(1.0f,1.0f),
media(0) { media(0) {
const Scope& sc = GetRequiredScope(element); const Scope& sc = GetRequiredScope(element);
@ -278,8 +278,8 @@ void LayeredTexture::fillTexture(const Document& doc) {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
Video::Video(uint64_t id, const Element& element, const Document& doc, const std::string& name) : Video::Video(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
Object(id,element,name), Object(id,element,name),
contentLength(0), contentLength(0),
content(0) { content(0) {
const Scope& sc = GetRequiredScope(element); const Scope& sc = GetRequiredScope(element);

2
code/AssetLib/FBX/FBXMeshGeometry.cpp
View File

@ -633,7 +633,7 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
{ {
return; return;
} }
// materials are handled separately. First of all, they are assigned per-face // materials are handled separately. First of all, they are assigned per-face
// and not per polyvert. Secondly, ReferenceInformationType=IndexToDirect // and not per polyvert. Secondly, ReferenceInformationType=IndexToDirect
// has a slightly different meaning for materials. // has a slightly different meaning for materials.

8
code/AssetLib/FBX/FBXMeshGeometry.h
View File

@ -52,8 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace Assimp { namespace Assimp {
namespace FBX { namespace FBX {
/** /**
* DOM base class for all kinds of FBX geometry * DOM base class for all kinds of FBX geometry
*/ */
class Geometry : public Object class Geometry : public Object
{ {
@ -76,7 +76,7 @@ private:
typedef std::vector<int> MatIndexArray; typedef std::vector<int> MatIndexArray;
/** /**
* DOM class for FBX geometry of type "Mesh" * DOM class for FBX geometry of type "Mesh"
*/ */
class MeshGeometry : public Geometry class MeshGeometry : public Geometry
@ -84,7 +84,7 @@ class MeshGeometry : public Geometry
public: public:
/** The class constructor */ /** The class constructor */
MeshGeometry( uint64_t id, const Element& element, const std::string& name, const Document& doc ); MeshGeometry( uint64_t id, const Element& element, const std::string& name, const Document& doc );
/** The class destructor */ /** The class destructor */
virtual ~MeshGeometry(); virtual ~MeshGeometry();

28
code/AssetLib/FBX/FBXParser.cpp
View File

@ -192,6 +192,10 @@ Scope::Scope(Parser& parser,bool topLevel)
} }
const std::string& str = n->StringContents(); const std::string& str = n->StringContents();
if (str.empty()) {
ParseError("unexpected content: empty string.");
}
elements.insert(ElementMap::value_type(str,new_Element(*n,parser))); elements.insert(ElementMap::value_type(str,new_Element(*n,parser)));
// Element() should stop at the next Key token (or right after a Close token) // Element() should stop at the next Key token (or right after a Close token)
@ -642,8 +646,7 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4); uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -733,8 +736,7 @@ void ParseVectorDataArray(std::vector<aiColor4D>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4); uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -816,8 +818,7 @@ void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4); uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -892,8 +893,7 @@ void ParseVectorDataArray(std::vector<int>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * 4; uint64_t dataToRead = static_cast<uint64_t>(count) * 4;
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -954,8 +954,7 @@ void ParseVectorDataArray(std::vector<float>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4); uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -1019,8 +1018,7 @@ void ParseVectorDataArray(std::vector<unsigned int>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * 4; uint64_t dataToRead = static_cast<uint64_t>(count) * 4;
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -1088,8 +1086,7 @@ void ParseVectorDataArray(std::vector<uint64_t>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * 8; uint64_t dataToRead = static_cast<uint64_t>(count) * 8;
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }
@ -1150,8 +1147,7 @@ void ParseVectorDataArray(std::vector<int64_t>& out, const Element& el)
ai_assert(data == end); ai_assert(data == end);
uint64_t dataToRead = static_cast<uint64_t>(count) * 8; uint64_t dataToRead = static_cast<uint64_t>(count) * 8;
ai_assert(buff.size() == dataToRead); if (dataToRead != buff.size()) {
if (dataToRead > buff.size()) {
ParseError("Invalid read size (binary)",&el); ParseError("Invalid read size (binary)",&el);
} }

6
code/AssetLib/FBX/FBXProperties.h
View File

@ -98,7 +98,7 @@ typedef std::fbx_unordered_map<std::string,std::shared_ptr<Property> > DirectPro
typedef std::fbx_unordered_map<std::string,const Property*> PropertyMap; typedef std::fbx_unordered_map<std::string,const Property*> PropertyMap;
typedef std::fbx_unordered_map<std::string,const Element*> LazyPropertyMap; typedef std::fbx_unordered_map<std::string,const Element*> LazyPropertyMap;
/** /**
* Represents a property table as can be found in the newer FBX files (Properties60, Properties70) * Represents a property table as can be found in the newer FBX files (Properties60, Properties70)
*/ */
class PropertyTable { class PropertyTable {
@ -130,7 +130,7 @@ private:
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename T> template <typename T>
inline inline
T PropertyGet(const PropertyTable& in, const std::string& name, const T& defaultValue) { T PropertyGet(const PropertyTable& in, const std::string& name, const T& defaultValue) {
const Property* const prop = in.Get(name); const Property* const prop = in.Get(name);
if( nullptr == prop) { if( nullptr == prop) {
@ -148,7 +148,7 @@ T PropertyGet(const PropertyTable& in, const std::string& name, const T& default
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename T> template <typename T>
inline inline
T PropertyGet(const PropertyTable& in, const std::string& name, bool& result, bool useTemplate=false ) { T PropertyGet(const PropertyTable& in, const std::string& name, bool& result, bool useTemplate=false ) {
const Property* prop = in.Get(name); const Property* prop = in.Get(name);
if( nullptr == prop) { if( nullptr == prop) {

2
code/AssetLib/FBX/FBXUtil.cpp
View File

@ -101,7 +101,7 @@ std::string GetLineAndColumnText(unsigned int line, unsigned int column)
std::string GetTokenText(const Token* tok) std::string GetTokenText(const Token* tok)
{ {
if(tok->IsBinary()) { if(tok->IsBinary()) {
return static_cast<std::string>( Formatter::format() << return static_cast<std::string>( Formatter::format() <<
" (" << TokenTypeString(tok->Type()) << " (" << TokenTypeString(tok->Type()) <<
", offset 0x" << std::hex << tok->Offset() << ") " ); ", offset 0x" << std::hex << tok->Offset() << ") " );
} }

4
code/AssetLib/HMP/HMPLoader.cpp
View File

@ -153,10 +153,10 @@ void HMPImporter::InternReadFile(const std::string &pFile,
} else { } else {
// Print the magic word to the logger // Print the magic word to the logger
std::string szBuffer = ai_str_toprintable((const char *)&iMagic, sizeof(iMagic)); std::string szBuffer = ai_str_toprintable((const char *)&iMagic, sizeof(iMagic));
delete[] mBuffer; delete[] mBuffer;
mBuffer = nullptr; mBuffer = nullptr;
// We're definitely unable to load this file // We're definitely unable to load this file
throw DeadlyImportError("Unknown HMP subformat ", pFile, throw DeadlyImportError("Unknown HMP subformat ", pFile,
". Magic word (", szBuffer, ") is not known"); ". Magic word (", szBuffer, ") is not known");

2
code/AssetLib/IFC/IFCCurve.cpp
View File

@ -514,7 +514,7 @@ IfcFloat Curve::GetParametricRangeDelta() const {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
size_t Curve::EstimateSampleCount(IfcFloat a, IfcFloat b) const { size_t Curve::EstimateSampleCount(IfcFloat a, IfcFloat b) const {
(void)(a); (void)(b); (void)(a); (void)(b);
ai_assert( InRange( a ) ); ai_assert( InRange( a ) );
ai_assert( InRange( b ) ); ai_assert( InRange( b ) );

8
code/AssetLib/IFC/IFCOpenings.cpp
View File

@ -911,14 +911,14 @@ size_t CloseWindows(ContourVector& contours,
// compare base poly normal and contour normal to detect if we need to reverse the face winding // compare base poly normal and contour normal to detect if we need to reverse the face winding
if(curmesh.mVertcnt.size() > 0) { if(curmesh.mVertcnt.size() > 0) {
IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front()); IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front());
std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size()); std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
for(size_t a = 0; a < it->contour.size(); ++a) for(size_t a = 0; a < it->contour.size(); ++a)
worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0); worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0);
IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size()); IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0; reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
} }

232
code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
View File

@ -5,8 +5,8 @@ Open Asset Import Library (ASSIMP)
Copyright (c) 2006-2020, ASSIMP Development Team Copyright (c) 2006-2020, ASSIMP Development Team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
@ -23,16 +23,16 @@ following conditions are met:
derived from this software without specific prior derived from this software without specific prior
written permission of the ASSIMP Development Team. written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
@ -1063,27 +1063,27 @@ template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoo
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); } do { // convert the 'GlobalId' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); } do { // convert the 'GlobalId' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->GlobalId, arg, db ); break; } try { GenericConvert( in->GlobalId, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
} while(0); } while(0);
do { // convert the 'OwnerHistory' argument do { // convert the 'OwnerHistory' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->OwnerHistory, arg, db ); break; } try { GenericConvert( in->OwnerHistory, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
} while(0); } while(0);
do { // convert the 'Name' argument do { // convert the 'Name' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[2]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'Description' argument do { // convert the 'Description' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[3]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[3]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Description, arg, db ); break; } try { GenericConvert( in->Description, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
} while(0); } while(0);
return base; return base;
@ -1150,27 +1150,27 @@ template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& para
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); } do { // convert the 'ContextOfItems' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); } do { // convert the 'ContextOfItems' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->ContextOfItems, arg, db ); break; } try { GenericConvert( in->ContextOfItems, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
} while(0); } while(0);
do { // convert the 'RepresentationIdentifier' argument do { // convert the 'RepresentationIdentifier' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; } try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'RepresentationType' argument do { // convert the 'RepresentationType' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RepresentationType, arg, db ); break; } try { GenericConvert( in->RepresentationType, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'Items' argument do { // convert the 'Items' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[3]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
try { GenericConvert( in->Items, arg, db ); break; } try { GenericConvert( in->Items, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
} while(0); } while(0);
return base; return base;
@ -1237,7 +1237,7 @@ template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcO
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcObject,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcObject,1>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ObjectType, arg, db ); break; } try { GenericConvert( in->ObjectType, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
} while(0); } while(0);
return base; return base;
@ -1290,20 +1290,20 @@ template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIS
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'Description' argument do { // convert the 'Description' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Description, arg, db ); break; } try { GenericConvert( in->Description, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
} while(0); } while(0);
do { // convert the 'Representations' argument do { // convert the 'Representations' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
try { GenericConvert( in->Representations, arg, db ); break; } try { GenericConvert( in->Representations, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
} while(0); } while(0);
return base; return base;
@ -1316,14 +1316,14 @@ template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, Ifc
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ObjectPlacement, arg, db ); break; } try { GenericConvert( in->ObjectPlacement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
} while(0); } while(0);
do { // convert the 'Representation' argument do { // convert the 'Representation' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Representation, arg, db ); break; } try { GenericConvert( in->Representation, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
} while(0); } while(0);
return base; return base;
@ -1336,7 +1336,7 @@ template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, Ifc
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElement,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElement,1>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Tag, arg, db ); break; } try { GenericConvert( in->Tag, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
} while(0); } while(0);
return base; return base;
@ -1374,13 +1374,13 @@ template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& para
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); } do { // convert the 'Segments' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); } do { // convert the 'Segments' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Segments, arg, db ); break; } try { GenericConvert( in->Segments, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
} while(0); } while(0);
do { // convert the 'SelfIntersect' argument do { // convert the 'SelfIntersect' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->SelfIntersect, arg, db ); break; } try { GenericConvert( in->SelfIntersect, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `LOGICAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `LOGICAL`")); }
} while(0); } while(0);
return base; return base;
@ -1400,27 +1400,27 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db,
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Axis1, arg, db ); break; } try { GenericConvert( in->Axis1, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
} while(0); } while(0);
do { // convert the 'Axis2' argument do { // convert the 'Axis2' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Axis2, arg, db ); break; } try { GenericConvert( in->Axis2, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
} while(0); } while(0);
do { // convert the 'LocalOrigin' argument do { // convert the 'LocalOrigin' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
try { GenericConvert( in->LocalOrigin, arg, db ); break; } try { GenericConvert( in->LocalOrigin, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
} while(0); } while(0);
do { // convert the 'Scale' argument do { // convert the 'Scale' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Scale, arg, db ); break; } try { GenericConvert( in->Scale, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `REAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `REAL`")); }
} while(0); } while(0);
return base; return base;
@ -1433,7 +1433,7 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& d
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Axis3, arg, db ); break; } try { GenericConvert( in->Axis3, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
} while(0); } while(0);
return base; return base;
@ -1445,14 +1445,14 @@ template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, If
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); } do { // convert the 'Name' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); } do { // convert the 'Name' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
} while(0); } while(0);
do { // convert the 'Description' argument do { // convert the 'Description' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Description, arg, db ); break; } try { GenericConvert( in->Description, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
} while(0); } while(0);
return base; return base;
@ -1497,7 +1497,7 @@ template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& p
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); } do { // convert the 'Position' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); } do { // convert the 'Position' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElementarySurface,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Position, arg, db ); break; } try { GenericConvert( in->Position, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
} while(0); } while(0);
return base; return base;
@ -1515,19 +1515,19 @@ template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& param
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); } do { // convert the 'Operator' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); } do { // convert the 'Operator' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Operator, arg, db ); break; } try { GenericConvert( in->Operator, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
} while(0); } while(0);
do { // convert the 'FirstOperand' argument do { // convert the 'FirstOperand' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->FirstOperand, arg, db ); break; } try { GenericConvert( in->FirstOperand, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
} while(0); } while(0);
do { // convert the 'SecondOperand' argument do { // convert the 'SecondOperand' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
try { GenericConvert( in->SecondOperand, arg, db ); break; } try { GenericConvert( in->SecondOperand, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
} while(0); } while(0);
return base; return base;
@ -1551,7 +1551,7 @@ template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& p
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); } do { // convert the 'Outer' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); } do { // convert the 'Outer' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Outer, arg, db ); break; } try { GenericConvert( in->Outer, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
} while(0); } while(0);
return base; return base;
@ -1630,12 +1630,12 @@ template <> size_t GenericFill<IfcRelFillsElement>(const DB& db, const LIST& par
size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in)); size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); } do { // convert the 'RelatingOpeningElement' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); } do { // convert the 'RelatingOpeningElement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; } try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); }
} while(0); } while(0);
do { // convert the 'RelatedBuildingElement' argument do { // convert the 'RelatedBuildingElement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; } try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); }
} while(0); } while(0);
return base; return base;
@ -1681,12 +1681,12 @@ template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db,
size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in)); size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); } do { // convert the 'RelatedElements' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); } do { // convert the 'RelatedElements' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelatedElements, arg, db ); break; } try { GenericConvert( in->RelatedElements, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); }
} while(0); } while(0);
do { // convert the 'RelatingStructure' argument do { // convert the 'RelatingStructure' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelatingStructure, arg, db ); break; } try { GenericConvert( in->RelatingStructure, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialStructureElement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialStructureElement`")); }
} while(0); } while(0);
return base; return base;
@ -1772,7 +1772,7 @@ template <> size_t GenericFill<IfcDirection>(const DB& db, const LIST& params, I
size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); } do { // convert the 'DirectionRatios' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); } do { // convert the 'DirectionRatios' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->DirectionRatios, arg, db ); break; } try { GenericConvert( in->DirectionRatios, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF REAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF REAL`")); }
} while(0); } while(0);
return base; return base;
@ -1784,14 +1784,14 @@ template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params,
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); } do { // convert the 'ProfileType' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); } do { // convert the 'ProfileType' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->ProfileType, arg, db ); break; } try { GenericConvert( in->ProfileType, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
} while(0); } while(0);
do { // convert the 'ProfileName' argument do { // convert the 'ProfileName' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ProfileName, arg, db ); break; } try { GenericConvert( in->ProfileName, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
} while(0); } while(0);
return base; return base;
@ -1803,7 +1803,7 @@ template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const L
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); } do { // convert the 'Position' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); } do { // convert the 'Position' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Position, arg, db ); break; } try { GenericConvert( in->Position, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
} while(0); } while(0);
return base; return base;
@ -1910,7 +1910,7 @@ template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& pa
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); } do { // convert the 'Radius' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); } do { // convert the 'Radius' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Radius, arg, db ); break; } try { GenericConvert( in->Radius, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -1921,7 +1921,7 @@ template <> size_t GenericFill<IfcCircleHollowProfileDef>(const DB& db, const LI
size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in)); size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in));
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); } do { // convert the 'WallThickness' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); } do { // convert the 'WallThickness' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->WallThickness, arg, db ); break; } try { GenericConvert( in->WallThickness, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -1933,7 +1933,7 @@ template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, I
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); } do { // convert the 'Location' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); } do { // convert the 'Location' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPlacement,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPlacement,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Location, arg, db ); break; } try { GenericConvert( in->Location, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
} while(0); } while(0);
return base; return base;
@ -1945,13 +1945,13 @@ template <> size_t GenericFill<IfcAxis2Placement3D>(const DB& db, const LIST& pa
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); } do { // convert the 'Axis' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); } do { // convert the 'Axis' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Axis, arg, db ); break; } try { GenericConvert( in->Axis, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); }
} while(0); } while(0);
do { // convert the 'RefDirection' argument do { // convert the 'RefDirection' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RefDirection, arg, db ); break; } try { GenericConvert( in->RefDirection, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); }
} while(0); } while(0);
return base; return base;
@ -1964,7 +1964,7 @@ template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& p
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
} while(0); } while(0);
return base; return base;
@ -1982,17 +1982,17 @@ template <> size_t GenericFill<IfcCompositeCurveSegment>(const DB& db, const LIS
size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); } do { // convert the 'Transition' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); } do { // convert the 'Transition' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Transition, arg, db ); break; } try { GenericConvert( in->Transition, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); }
} while(0); } while(0);
do { // convert the 'SameSense' argument do { // convert the 'SameSense' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->SameSense, arg, db ); break; } try { GenericConvert( in->SameSense, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `BOOLEAN`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `BOOLEAN`")); }
} while(0); } while(0);
do { // convert the 'ParentCurve' argument do { // convert the 'ParentCurve' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ParentCurve, arg, db ); break; } try { GenericConvert( in->ParentCurve, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); }
} while(0); } while(0);
return base; return base;
@ -2004,13 +2004,13 @@ template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST&
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); } do { // convert the 'XDim' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); } do { // convert the 'XDim' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->XDim, arg, db ); break; } try { GenericConvert( in->XDim, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'YDim' argument do { // convert the 'YDim' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->YDim, arg, db ); break; } try { GenericConvert( in->YDim, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -2106,12 +2106,12 @@ template <> size_t GenericFill<IfcLocalPlacement>(const DB& db, const LIST& para
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); } do { // convert the 'PlacementRelTo' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); } do { // convert the 'PlacementRelTo' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->PlacementRelTo, arg, db ); break; } try { GenericConvert( in->PlacementRelTo, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); }
} while(0); } while(0);
do { // convert the 'RelativePlacement' argument do { // convert the 'RelativePlacement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelativePlacement, arg, db ); break; } try { GenericConvert( in->RelativePlacement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); }
} while(0); } while(0);
return base; return base;
@ -2123,13 +2123,13 @@ template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& para
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); } do { // convert the 'SweptArea' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); } do { // convert the 'SweptArea' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->SweptArea, arg, db ); break; } try { GenericConvert( in->SweptArea, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
} while(0); } while(0);
do { // convert the 'Position' argument do { // convert the 'Position' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->Position, arg, db ); break; } try { GenericConvert( in->Position, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
} while(0); } while(0);
return base; return base;
@ -2140,12 +2140,12 @@ template <> size_t GenericFill<IfcRevolvedAreaSolid>(const DB& db, const LIST& p
size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in)); size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); } do { // convert the 'Axis' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); } do { // convert the 'Axis' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Axis, arg, db ); break; } try { GenericConvert( in->Axis, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); }
} while(0); } while(0);
do { // convert the 'Angle' argument do { // convert the 'Angle' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Angle, arg, db ); break; } try { GenericConvert( in->Angle, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -2170,28 +2170,28 @@ template <> size_t GenericFill<IfcSweptDiskSolid>(const DB& db, const LIST& para
size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in)); size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); } do { // convert the 'Directrix' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); } do { // convert the 'Directrix' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Directrix, arg, db ); break; } try { GenericConvert( in->Directrix, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); }
} while(0); } while(0);
do { // convert the 'Radius' argument do { // convert the 'Radius' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Radius, arg, db ); break; } try { GenericConvert( in->Radius, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'InnerRadius' argument do { // convert the 'InnerRadius' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->InnerRadius, arg, db ); break; } try { GenericConvert( in->InnerRadius, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'StartParam' argument do { // convert the 'StartParam' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->StartParam, arg, db ); break; } try { GenericConvert( in->StartParam, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
} while(0); } while(0);
do { // convert the 'EndParam' argument do { // convert the 'EndParam' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->EndParam, arg, db ); break; } try { GenericConvert( in->EndParam, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
} while(0); } while(0);
return base; return base;
@ -2203,13 +2203,13 @@ template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& para
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); } do { // convert the 'BaseSurface' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); } do { // convert the 'BaseSurface' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->BaseSurface, arg, db ); break; } try { GenericConvert( in->BaseSurface, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
} while(0); } while(0);
do { // convert the 'AgreementFlag' argument do { // convert the 'AgreementFlag' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->AgreementFlag, arg, db ); break; } try { GenericConvert( in->AgreementFlag, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `BOOLEAN`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `BOOLEAN`")); }
} while(0); } while(0);
return base; return base;
@ -2220,12 +2220,12 @@ template <> size_t GenericFill<IfcPolygonalBoundedHalfSpace>(const DB& db, const
size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in)); size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); } do { // convert the 'Position' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); } do { // convert the 'Position' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Position, arg, db ); break; } try { GenericConvert( in->Position, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); }
} while(0); } while(0);
do { // convert the 'PolygonalBoundary' argument do { // convert the 'PolygonalBoundary' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->PolygonalBoundary, arg, db ); break; } try { GenericConvert( in->PolygonalBoundary, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); }
} while(0); } while(0);
return base; return base;
@ -2251,23 +2251,23 @@ template <> size_t GenericFill<IfcProject>(const DB& db, const LIST& params, Ifc
if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); } do { // convert the 'LongName' argument if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); } do { // convert the 'LongName' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->LongName, arg, db ); break; } try { GenericConvert( in->LongName, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProject to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProject to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'Phase' argument do { // convert the 'Phase' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Phase, arg, db ); break; } try { GenericConvert( in->Phase, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProject to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProject to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'RepresentationContexts' argument do { // convert the 'RepresentationContexts' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RepresentationContexts, arg, db ); break; } try { GenericConvert( in->RepresentationContexts, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcProject to be a `SET [1:?] OF IfcRepresentationContext`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcProject to be a `SET [1:?] OF IfcRepresentationContext`")); }
} while(0); } while(0);
do { // convert the 'UnitsInContext' argument do { // convert the 'UnitsInContext' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->UnitsInContext, arg, db ); break; } try { GenericConvert( in->UnitsInContext, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcProject to be a `IfcUnitAssignment`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcProject to be a `IfcUnitAssignment`")); }
} while(0); } while(0);
return base; return base;
@ -2327,27 +2327,27 @@ template <> size_t GenericFill<IfcTrimmedCurve>(const DB& db, const LIST& params
size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in)); size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); } do { // convert the 'BasisCurve' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); } do { // convert the 'BasisCurve' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->BasisCurve, arg, db ); break; } try { GenericConvert( in->BasisCurve, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); }
} while(0); } while(0);
do { // convert the 'Trim1' argument do { // convert the 'Trim1' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Trim1, arg, db ); break; } try { GenericConvert( in->Trim1, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
} while(0); } while(0);
do { // convert the 'Trim2' argument do { // convert the 'Trim2' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Trim2, arg, db ); break; } try { GenericConvert( in->Trim2, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
} while(0); } while(0);
do { // convert the 'SenseAgreement' argument do { // convert the 'SenseAgreement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->SenseAgreement, arg, db ); break; } try { GenericConvert( in->SenseAgreement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `BOOLEAN`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `BOOLEAN`")); }
} while(0); } while(0);
do { // convert the 'MasterRepresentation' argument do { // convert the 'MasterRepresentation' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->MasterRepresentation, arg, db ); break; } try { GenericConvert( in->MasterRepresentation, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); }
} while(0); } while(0);
return base; return base;
@ -2359,7 +2359,7 @@ template <> size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params,
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRelDefines"); } do { // convert the 'RelatedObjects' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRelDefines"); } do { // convert the 'RelatedObjects' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefines,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefines,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->RelatedObjects, arg, db ); break; } try { GenericConvert( in->RelatedObjects, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefines to be a `SET [1:?] OF IfcObject`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefines to be a `SET [1:?] OF IfcObject`")); }
} while(0); } while(0);
return base; return base;
@ -2371,7 +2371,7 @@ template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LI
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); } do { // convert the 'RelatingPropertyDefinition' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); } do { // convert the 'RelatingPropertyDefinition' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefinesByProperties,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefinesByProperties,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; } try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinition`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinition`")); }
} while(0); } while(0);
return base; return base;
@ -2404,7 +2404,7 @@ template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const L
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); } do { // convert the 'Curve' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); } do { // convert the 'Curve' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Curve, arg, db ); break; } try { GenericConvert( in->Curve, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
} while(0); } while(0);
return base; return base;
@ -2570,13 +2570,13 @@ template <> size_t GenericFill<IfcRelDecomposes>(const DB& db, const LIST& param
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDecomposes"); } do { // convert the 'RelatingObject' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDecomposes"); } do { // convert the 'RelatingObject' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->RelatingObject, arg, db ); break; } try { GenericConvert( in->RelatingObject, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDecomposes to be a `IfcObjectDefinition`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDecomposes to be a `IfcObjectDefinition`")); }
} while(0); } while(0);
do { // convert the 'RelatedObjects' argument do { // convert the 'RelatedObjects' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->RelatedObjects, arg, db ); break; } try { GenericConvert( in->RelatedObjects, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDecomposes to be a `SET [1:?] OF IfcObjectDefinition`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDecomposes to be a `SET [1:?] OF IfcObjectDefinition`")); }
} while(0); } while(0);
return base; return base;
@ -2594,7 +2594,7 @@ template <> size_t GenericFill<IfcPolyline>(const DB& db, const LIST& params, If
size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in)); size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); } do { // convert the 'Points' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); } do { // convert the 'Points' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Points, arg, db ); break; } try { GenericConvert( in->Points, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); }
} while(0); } while(0);
return base; return base;
@ -2626,12 +2626,12 @@ template <> size_t GenericFill<IfcMappedItem>(const DB& db, const LIST& params,
size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); } do { // convert the 'MappingSource' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); } do { // convert the 'MappingSource' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->MappingSource, arg, db ); break; } try { GenericConvert( in->MappingSource, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); }
} while(0); } while(0);
do { // convert the 'MappingTarget' argument do { // convert the 'MappingTarget' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->MappingTarget, arg, db ); break; } try { GenericConvert( in->MappingTarget, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); }
} while(0); } while(0);
return base; return base;
@ -2658,13 +2658,13 @@ template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, I
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Dimensions, arg, db ); break; } try { GenericConvert( in->Dimensions, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
} while(0); } while(0);
do { // convert the 'UnitType' argument do { // convert the 'UnitType' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->UnitType, arg, db ); break; } try { GenericConvert( in->UnitType, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
} while(0); } while(0);
return base; return base;
@ -2719,13 +2719,13 @@ template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const L
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->LongName, arg, db ); break; } try { GenericConvert( in->LongName, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialStructureElement to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialStructureElement to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'CompositionType' argument do { // convert the 'CompositionType' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->CompositionType, arg, db ); break; } try { GenericConvert( in->CompositionType, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
} while(0); } while(0);
return base; return base;
@ -2737,19 +2737,19 @@ template <> size_t GenericFill<IfcBuilding>(const DB& db, const LIST& params, If
if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); } do { // convert the 'ElevationOfRefHeight' argument if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); } do { // convert the 'ElevationOfRefHeight' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; } try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'ElevationOfTerrain' argument do { // convert the 'ElevationOfTerrain' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; } try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'BuildingAddress' argument do { // convert the 'BuildingAddress' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->BuildingAddress, arg, db ); break; } try { GenericConvert( in->BuildingAddress, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); }
} while(0); } while(0);
return base; return base;
@ -2761,7 +2761,7 @@ template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& pa
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); } do { // convert the 'CfsFaces' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); } do { // convert the 'CfsFaces' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->CfsFaces, arg, db ); break; } try { GenericConvert( in->CfsFaces, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
} while(0); } while(0);
return base; return base;
@ -2787,7 +2787,7 @@ template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcCo
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); } do { // convert the 'Position' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); } do { // convert the 'Position' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConic,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConic,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Position, arg, db ); break; } try { GenericConvert( in->Position, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
} while(0); } while(0);
return base; return base;
@ -2834,32 +2834,32 @@ template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& pa
if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcIShapeProfileDef"); } do { // convert the 'OverallWidth' argument if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcIShapeProfileDef"); } do { // convert the 'OverallWidth' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->OverallWidth, arg, db ); break; } try { GenericConvert( in->OverallWidth, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'OverallDepth' argument do { // convert the 'OverallDepth' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->OverallDepth, arg, db ); break; } try { GenericConvert( in->OverallDepth, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'WebThickness' argument do { // convert the 'WebThickness' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[2]=true; break; }
try { GenericConvert( in->WebThickness, arg, db ); break; } try { GenericConvert( in->WebThickness, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'FlangeThickness' argument do { // convert the 'FlangeThickness' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[3]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[3]=true; break; }
try { GenericConvert( in->FlangeThickness, arg, db ); break; } try { GenericConvert( in->FlangeThickness, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'FilletRadius' argument do { // convert the 'FilletRadius' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[4]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[4]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->FilletRadius, arg, db ); break; } try { GenericConvert( in->FilletRadius, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -2933,13 +2933,13 @@ template <> size_t GenericFill<IfcPropertyListValue>(const DB& db, const LIST& p
size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in)); size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); } do { // convert the 'ListValues' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); } do { // convert the 'ListValues' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ListValues, arg, db ); break; } try { GenericConvert( in->ListValues, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); }
} while(0); } while(0);
do { // convert the 'Unit' argument do { // convert the 'Unit' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Unit, arg, db ); break; } try { GenericConvert( in->Unit, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); }
} while(0); } while(0);
return base; return base;
@ -2965,13 +2965,13 @@ template <> size_t GenericFill<IfcDoor>(const DB& db, const LIST& params, IfcDoo
if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcDoor"); } do { // convert the 'OverallHeight' argument if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcDoor"); } do { // convert the 'OverallHeight' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->OverallHeight, arg, db ); break; } try { GenericConvert( in->OverallHeight, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'OverallWidth' argument do { // convert the 'OverallWidth' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->OverallWidth, arg, db ); break; } try { GenericConvert( in->OverallWidth, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -2984,20 +2984,20 @@ template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params,
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Item, arg, db ); break; } try { GenericConvert( in->Item, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
} while(0); } while(0);
do { // convert the 'Styles' argument do { // convert the 'Styles' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->Styles, arg, db ); break; } try { GenericConvert( in->Styles, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcPresentationStyleAssignment`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcPresentationStyleAssignment`")); }
} while(0); } while(0);
do { // convert the 'Name' argument do { // convert the 'Name' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[2]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
} while(0); } while(0);
return base; return base;
@ -3023,7 +3023,7 @@ template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); } do { // convert the 'OuterCurve' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); } do { // convert the 'OuterCurve' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->OuterCurve, arg, db ); break; } try { GenericConvert( in->OuterCurve, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
} while(0); } while(0);
return base; return base;
@ -3041,12 +3041,12 @@ template <> size_t GenericFill<IfcLine>(const DB& db, const LIST& params, IfcLin
size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in)); size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); } do { // convert the 'Pnt' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); } do { // convert the 'Pnt' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Pnt, arg, db ); break; } try { GenericConvert( in->Pnt, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); }
} while(0); } while(0);
do { // convert the 'Dir' argument do { // convert the 'Dir' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Dir, arg, db ); break; } try { GenericConvert( in->Dir, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); }
} while(0); } while(0);
return base; return base;
@ -3072,13 +3072,13 @@ template <> size_t GenericFill<IfcPropertySingleValue>(const DB& db, const LIST&
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); } do { // convert the 'NominalValue' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); } do { // convert the 'NominalValue' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->NominalValue, arg, db ); break; } try { GenericConvert( in->NominalValue, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); }
} while(0); } while(0);
do { // convert the 'Unit' argument do { // convert the 'Unit' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Unit, arg, db ); break; } try { GenericConvert( in->Unit, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); }
} while(0); } while(0);
return base; return base;
@ -3111,7 +3111,7 @@ template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST&
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleShading"); } do { // convert the 'SurfaceColour' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleShading"); } do { // convert the 'SurfaceColour' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurfaceStyleShading,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurfaceStyleShading,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->SurfaceColour, arg, db ); break; } try { GenericConvert( in->SurfaceColour, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
} while(0); } while(0);
return base; return base;

162
code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
View File

@ -5,8 +5,8 @@ Open Asset Import Library (ASSIMP)
Copyright (c) 2006-2020, ASSIMP Development Team Copyright (c) 2006-2020, ASSIMP Development Team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
@ -23,16 +23,16 @@ following conditions are met:
derived from this software without specific prior derived from this software without specific prior
written permission of the ASSIMP Development Team. written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
@ -59,12 +59,12 @@ template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params
size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in)); size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); } do { // convert the 'Side' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); } do { // convert the 'Side' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Side, arg, db ); break; } try { GenericConvert( in->Side, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
} while(0); } while(0);
do { // convert the 'Styles' argument do { // convert the 'Styles' argument
std::shared_ptr<const DataType> arg = params[ base++ ]; std::shared_ptr<const DataType> arg = params[ base++ ];
try { GenericConvert( in->Styles, arg, db ); break; } try { GenericConvert( in->Styles, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
} while(0); } while(0);
return base; return base;
@ -118,7 +118,7 @@ template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFac
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); } do { // convert the 'Bounds' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); } do { // convert the 'Bounds' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFace,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFace,1>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Bounds, arg, db ); break; } try { GenericConvert( in->Bounds, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
} while(0); } while(0);
return base; return base;
@ -173,7 +173,7 @@ template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST&
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcColourSpecification,1>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
} while(0); } while(0);
return base; return base;
@ -184,12 +184,12 @@ template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcV
size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); } do { // convert the 'Orientation' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); } do { // convert the 'Orientation' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Orientation, arg, db ); break; } try { GenericConvert( in->Orientation, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
} while(0); } while(0);
do { // convert the 'Magnitude' argument do { // convert the 'Magnitude' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Magnitude, arg, db ); break; } try { GenericConvert( in->Magnitude, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -207,17 +207,17 @@ template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, I
size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in)); size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); } do { // convert the 'Red' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); } do { // convert the 'Red' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Red, arg, db ); break; } try { GenericConvert( in->Red, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
} while(0); } while(0);
do { // convert the 'Green' argument do { // convert the 'Green' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Green, arg, db ); break; } try { GenericConvert( in->Green, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
} while(0); } while(0);
do { // convert the 'Blue' argument do { // convert the 'Blue' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Blue, arg, db ); break; } try { GenericConvert( in->Blue, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -243,31 +243,31 @@ template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSit
if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); } do { // convert the 'RefLatitude' argument if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); } do { // convert the 'RefLatitude' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RefLatitude, arg, db ); break; } try { GenericConvert( in->RefLatitude, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
} while(0); } while(0);
do { // convert the 'RefLongitude' argument do { // convert the 'RefLongitude' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RefLongitude, arg, db ); break; } try { GenericConvert( in->RefLongitude, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
} while(0); } while(0);
do { // convert the 'RefElevation' argument do { // convert the 'RefElevation' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RefElevation, arg, db ); break; } try { GenericConvert( in->RefElevation, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'LandTitleNumber' argument do { // convert the 'LandTitleNumber' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->LandTitleNumber, arg, db ); break; } try { GenericConvert( in->LandTitleNumber, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'SiteAddress' argument do { // convert the 'SiteAddress' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->SiteAddress, arg, db ); break; } try { GenericConvert( in->SiteAddress, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
} while(0); } while(0);
return base; return base;
@ -412,31 +412,31 @@ template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); } do { // convert the 'Degree' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); } do { // convert the 'Degree' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Degree, arg, db ); break; } try { GenericConvert( in->Degree, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `INTEGER`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `INTEGER`")); }
} while(0); } while(0);
do { // convert the 'ControlPointsList' argument do { // convert the 'ControlPointsList' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->ControlPointsList, arg, db ); break; } try { GenericConvert( in->ControlPointsList, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
} while(0); } while(0);
do { // convert the 'CurveForm' argument do { // convert the 'CurveForm' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
try { GenericConvert( in->CurveForm, arg, db ); break; } try { GenericConvert( in->CurveForm, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
} while(0); } while(0);
do { // convert the 'ClosedCurve' argument do { // convert the 'ClosedCurve' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
try { GenericConvert( in->ClosedCurve, arg, db ); break; } try { GenericConvert( in->ClosedCurve, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `LOGICAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `LOGICAL`")); }
} while(0); } while(0);
do { // convert the 'SelfIntersect' argument do { // convert the 'SelfIntersect' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
try { GenericConvert( in->SelfIntersect, arg, db ); break; } try { GenericConvert( in->SelfIntersect, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `LOGICAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `LOGICAL`")); }
} while(0); } while(0);
return base; return base;
@ -474,7 +474,7 @@ template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LI
size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); } do { // convert the 'SbsmBoundary' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); } do { // convert the 'SbsmBoundary' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->SbsmBoundary, arg, db ); break; } try { GenericConvert( in->SbsmBoundary, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
} while(0); } while(0);
return base; return base;
@ -492,12 +492,12 @@ template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& p
size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in)); size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); } do { // convert the 'ExtrudedDirection' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); } do { // convert the 'ExtrudedDirection' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ExtrudedDirection, arg, db ); break; } try { GenericConvert( in->ExtrudedDirection, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
} while(0); } while(0);
do { // convert the 'Depth' argument do { // convert the 'Depth' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Depth, arg, db ); break; } try { GenericConvert( in->Depth, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -522,12 +522,12 @@ template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& par
size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in)); size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); } do { // convert the 'RelatingBuildingElement' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); } do { // convert the 'RelatingBuildingElement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; } try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
} while(0); } while(0);
do { // convert the 'RelatedOpeningElement' argument do { // convert the 'RelatedOpeningElement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; } try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
} while(0); } while(0);
return base; return base;
@ -546,13 +546,13 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(c
if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); } do { // convert the 'Scale2' argument if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); } do { // convert the 'Scale2' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Scale2, arg, db ); break; } try { GenericConvert( in->Scale2, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
} while(0); } while(0);
do { // convert the 'Scale3' argument do { // convert the 'Scale3' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Scale3, arg, db ); break; } try { GenericConvert( in->Scale3, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
} while(0); } while(0);
return base; return base;
@ -634,7 +634,7 @@ template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& pa
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); } do { // convert the 'RefDirection' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); } do { // convert the 'RefDirection' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->RefDirection, arg, db ); break; } try { GenericConvert( in->RefDirection, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
} while(0); } while(0);
return base; return base;
@ -658,7 +658,7 @@ template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& para
size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in)); size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); } do { // convert the 'Coordinates' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); } do { // convert the 'Coordinates' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Coordinates, arg, db ); break; } try { GenericConvert( in->Coordinates, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -682,7 +682,7 @@ template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, If
size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in)); size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); } do { // convert the 'Polygon' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); } do { // convert the 'Polygon' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Polygon, arg, db ); break; } try { GenericConvert( in->Polygon, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
} while(0); } while(0);
return base; return base;
@ -716,14 +716,14 @@ template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIS
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ContextIdentifier, arg, db ); break; } try { GenericConvert( in->ContextIdentifier, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'ContextType' argument do { // convert the 'ContextType' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ContextType, arg, db ); break; } try { GenericConvert( in->ContextType, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
} while(0); } while(0);
return base; return base;
@ -735,27 +735,27 @@ template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db,
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); } do { // convert the 'CoordinateSpaceDimension' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); } do { // convert the 'CoordinateSpaceDimension' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; } try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
} while(0); } while(0);
do { // convert the 'Precision' argument do { // convert the 'Precision' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Precision, arg, db ); break; } try { GenericConvert( in->Precision, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `REAL`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `REAL`")); }
} while(0); } while(0);
do { // convert the 'WorldCoordinateSystem' argument do { // convert the 'WorldCoordinateSystem' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; } try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
} while(0); } while(0);
do { // convert the 'TrueNorth' argument do { // convert the 'TrueNorth' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->TrueNorth, arg, db ); break; } try { GenericConvert( in->TrueNorth, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
} while(0); } while(0);
return base; return base;
@ -774,12 +774,12 @@ template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcS
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); } do { // convert the 'Prefix' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); } do { // convert the 'Prefix' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Prefix, arg, db ); break; } try { GenericConvert( in->Prefix, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
} while(0); } while(0);
do { // convert the 'Name' argument do { // convert the 'Name' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
} while(0); } while(0);
return base; return base;
@ -805,7 +805,7 @@ template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& para
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); } do { // convert the 'Axis' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); } do { // convert the 'Axis' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Axis, arg, db ); break; } try { GenericConvert( in->Axis, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
} while(0); } while(0);
return base; return base;
@ -858,12 +858,12 @@ template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& p
size_t base = 0; size_t base = 0;
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); } do { // convert the 'MappingOrigin' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); } do { // convert the 'MappingOrigin' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->MappingOrigin, arg, db ); break; } try { GenericConvert( in->MappingOrigin, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
} while(0); } while(0);
do { // convert the 'MappedRepresentation' argument do { // convert the 'MappedRepresentation' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->MappedRepresentation, arg, db ); break; } try { GenericConvert( in->MappedRepresentation, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
} while(0); } while(0);
return base; return base;
@ -1012,12 +1012,12 @@ template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& par
size_t base = 0; size_t base = 0;
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); } do { // convert the 'ValueComponent' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); } do { // convert the 'ValueComponent' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ValueComponent, arg, db ); break; } try { GenericConvert( in->ValueComponent, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
} while(0); } while(0);
do { // convert the 'UnitComponent' argument do { // convert the 'UnitComponent' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->UnitComponent, arg, db ); break; } try { GenericConvert( in->UnitComponent, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
} while(0); } while(0);
return base; return base;
@ -1125,7 +1125,7 @@ template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIS
size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); } do { // convert the 'FbsmFaces' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); } do { // convert the 'FbsmFaces' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->FbsmFaces, arg, db ); break; } try { GenericConvert( in->FbsmFaces, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
} while(0); } while(0);
return base; return base;
@ -1172,13 +1172,13 @@ template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, I
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); } do { // convert the 'Bound' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); } do { // convert the 'Bound' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[0]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
try { GenericConvert( in->Bound, arg, db ); break; } try { GenericConvert( in->Bound, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
} while(0); } while(0);
do { // convert the 'Orientation' argument do { // convert the 'Orientation' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[1]=true; break; } if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
try { GenericConvert( in->Orientation, arg, db ); break; } try { GenericConvert( in->Orientation, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `BOOLEAN`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `BOOLEAN`")); }
} while(0); } while(0);
return base; return base;
@ -1216,12 +1216,12 @@ template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& par
size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in)); size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); } do { // convert the 'UsageName' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); } do { // convert the 'UsageName' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->UsageName, arg, db ); break; } try { GenericConvert( in->UsageName, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
} while(0); } while(0);
do { // convert the 'HasProperties' argument do { // convert the 'HasProperties' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->HasProperties, arg, db ); break; } try { GenericConvert( in->HasProperties, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
} while(0); } while(0);
return base; return base;
@ -1274,7 +1274,7 @@ template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& para
size_t base = 0; size_t base = 0;
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); } do { // convert the 'Units' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); } do { // convert the 'Units' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Units, arg, db ); break; } try { GenericConvert( in->Units, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
} while(0); } while(0);
return base; return base;
@ -1307,12 +1307,12 @@ template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& par
if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); } do { // convert the 'MethodOfMeasurement' argument if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); } do { // convert the 'MethodOfMeasurement' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; } try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'Quantities' argument do { // convert the 'Quantities' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Quantities, arg, db ); break; } try { GenericConvert( in->Quantities, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
} while(0); } while(0);
return base; return base;
@ -1379,7 +1379,7 @@ template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, con
size_t base = 0; size_t base = 0;
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); } do { // convert the 'Styles' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); } do { // convert the 'Styles' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Styles, arg, db ); break; } try { GenericConvert( in->Styles, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
} while(0); } while(0);
return base; return base;
@ -1418,13 +1418,13 @@ template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSp
size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in)); size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); } do { // convert the 'InteriorOrExteriorSpace' argument if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); } do { // convert the 'InteriorOrExteriorSpace' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; } try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcInternalOrExternalEnum`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcInternalOrExternalEnum`")); }
} while(0); } while(0);
do { // convert the 'ElevationWithFlooring' argument do { // convert the 'ElevationWithFlooring' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; } try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -1484,7 +1484,7 @@ template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const
size_t base = 0; size_t base = 0;
if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); } do { // convert the 'Textures' argument if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); } do { // convert the 'Textures' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Textures, arg, db ); break; } try { GenericConvert( in->Textures, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
} while(0); } while(0);
return base; return base;
@ -1495,22 +1495,22 @@ template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params,
size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in)); size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); } do { // convert the 'Corner' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); } do { // convert the 'Corner' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Corner, arg, db ); break; } try { GenericConvert( in->Corner, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
} while(0); } while(0);
do { // convert the 'XDim' argument do { // convert the 'XDim' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->XDim, arg, db ); break; } try { GenericConvert( in->XDim, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'YDim' argument do { // convert the 'YDim' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->YDim, arg, db ); break; } try { GenericConvert( in->YDim, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'ZDim' argument do { // convert the 'ZDim' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ZDim, arg, db ); break; } try { GenericConvert( in->ZDim, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -1535,7 +1535,7 @@ template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcC
size_t base = GenericFill(db,params,static_cast<IfcConic*>(in)); size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); } do { // convert the 'Radius' argument if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); } do { // convert the 'Radius' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Radius, arg, db ); break; } try { GenericConvert( in->Radius, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -1623,12 +1623,12 @@ template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST&
size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in)); size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); } do { // convert the 'Name' argument if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); } do { // convert the 'Name' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->Name, arg, db ); break; } try { GenericConvert( in->Name, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
} while(0); } while(0);
do { // convert the 'ConversionFactor' argument do { // convert the 'ConversionFactor' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ConversionFactor, arg, db ); break; } try { GenericConvert( in->ConversionFactor, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
} while(0); } while(0);
return base; return base;
@ -1744,12 +1744,12 @@ template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, Ifc
size_t base = GenericFill(db,params,static_cast<IfcConic*>(in)); size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); } do { // convert the 'SemiAxis1' argument if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); } do { // convert the 'SemiAxis1' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->SemiAxis1, arg, db ); break; } try { GenericConvert( in->SemiAxis1, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
do { // convert the 'SemiAxis2' argument do { // convert the 'SemiAxis2' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->SemiAxis2, arg, db ); break; } try { GenericConvert( in->SemiAxis2, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
} while(0); } while(0);
return base; return base;
@ -1816,7 +1816,7 @@ template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params,
size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in)); size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); } do { // convert the 'HasProperties' argument if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); } do { // convert the 'HasProperties' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->HasProperties, arg, db ); break; } try { GenericConvert( in->HasProperties, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
} while(0); } while(0);
return base; return base;
@ -1828,48 +1828,48 @@ template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIS
if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); } do { // convert the 'Transparency' argument if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); } do { // convert the 'Transparency' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->Transparency, arg, db ); break; } try { GenericConvert( in->Transparency, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleRendering to be a `IfcNormalisedRatioMeasure`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleRendering to be a `IfcNormalisedRatioMeasure`")); }
} while(0); } while(0);
do { // convert the 'DiffuseColour' argument do { // convert the 'DiffuseColour' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->DiffuseColour, arg, db ); break; } try { GenericConvert( in->DiffuseColour, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
} while(0); } while(0);
do { // convert the 'TransmissionColour' argument do { // convert the 'TransmissionColour' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->TransmissionColour, arg, db ); break; } try { GenericConvert( in->TransmissionColour, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
} while(0); } while(0);
do { // convert the 'DiffuseTransmissionColour' argument do { // convert the 'DiffuseTransmissionColour' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; } try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
} while(0); } while(0);
do { // convert the 'ReflectionColour' argument do { // convert the 'ReflectionColour' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->ReflectionColour, arg, db ); break; } try { GenericConvert( in->ReflectionColour, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
} while(0); } while(0);
do { // convert the 'SpecularColour' argument do { // convert the 'SpecularColour' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->SpecularColour, arg, db ); break; } try { GenericConvert( in->SpecularColour, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
} while(0); } while(0);
do { // convert the 'SpecularHighlight' argument do { // convert the 'SpecularHighlight' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
if (dynamic_cast<const UNSET*>(&*arg)) break; if (dynamic_cast<const UNSET*>(&*arg)) break;
try { GenericConvert( in->SpecularHighlight, arg, db ); break; } try { GenericConvert( in->SpecularHighlight, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
} while(0); } while(0);
do { // convert the 'ReflectanceMethod' argument do { // convert the 'ReflectanceMethod' argument
std::shared_ptr<const DataType> arg = params[base++]; std::shared_ptr<const DataType> arg = params[base++];
try { GenericConvert( in->ReflectanceMethod, arg, db ); break; } try { GenericConvert( in->ReflectanceMethod, arg, db ); break; }
catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
} while(0); } while(0);
return base; return base;

392
code/AssetLib/IFC/IFCReaderGen_4.cpp
View File

File diff suppressed because it is too large Load Diff

26
code/AssetLib/IFC/IFCReaderGen_4.h
View File

@ -5,8 +5,8 @@ Open Asset Import Library (ASSIMP)
Copyright (c) 2006-2020, ASSIMP Development Team Copyright (c) 2006-2020, ASSIMP Development Team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
@ -23,16 +23,16 @@ following conditions are met:
derived from this software without specific prior derived from this software without specific prior
written permission of the ASSIMP Development Team. written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
@ -51,12 +51,12 @@ namespace Schema_4 {
using namespace STEP; using namespace STEP;
using namespace STEP::EXPRESS; using namespace STEP::EXPRESS;
struct NotImplemented : public ObjectHelper<NotImplemented,0> { struct NotImplemented : public ObjectHelper<NotImplemented,0> {
}; };
// ****************************************************************************** // ******************************************************************************
// IFC Custom data types // IFC Custom data types

2
code/AssetLib/Irr/IRRLoader.h
View File

@ -273,7 +273,7 @@ private:
std::vector<aiNodeAnim*>& anims); std::vector<aiNodeAnim*>& anims);
private: private:
/// Configuration option: desired output FPS /// Configuration option: desired output FPS
double fps; double fps;
/// Configuration option: speed flag was set? /// Configuration option: speed flag was set?

2
code/AssetLib/LWO/LWOAnimation.h
View File

@ -114,7 +114,7 @@ enum PrePostBehaviour
/** \brief Data structure for a LWO animation keyframe /** \brief Data structure for a LWO animation keyframe
*/ */
struct Key { struct Key {
Key() AI_NO_EXCEPT Key() AI_NO_EXCEPT
: time() : time()
, value() , value()
, inter(IT_LINE) , inter(IT_LINE)

4
code/AssetLib/LWS/LWSLoader.cpp
View File

@ -200,7 +200,7 @@ void LWSImporter::ReadEnvelope(const LWS::Element &dad, LWO::Envelope &fill) {
// reserve enough storage // reserve enough storage
std::list<LWS::Element>::const_iterator it = dad.children.begin(); std::list<LWS::Element>::const_iterator it = dad.children.begin();
fill.keys.reserve(strtoul10(it->tokens[1].c_str())); fill.keys.reserve(strtoul10(it->tokens[1].c_str()));
for (++it; it != dad.children.end(); ++it) { for (++it; it != dad.children.end(); ++it) {
@ -466,7 +466,7 @@ std::string LWSImporter::FindLWOFile(const std::string &in) {
std::string tmp(in); std::string tmp(in);
if (in.length() > 3 && in[1] == ':' && in[2] != '\\' && in[2] != '/') { if (in.length() > 3 && in[1] == ':' && in[2] != '\\' && in[2] != '/') {
tmp = in[0] + (std::string(":\\") + in.substr(2)); tmp = in[0] + (std::string(":\\") + in.substr(2));
} }
if (io->Exists(tmp)) { if (io->Exists(tmp)) {
return in; return in;

14
code/AssetLib/M3D/M3DImporter.cpp
View File

@ -233,12 +233,12 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d) {
ASSIMP_LOG_DEBUG("M3D: importMaterials ", mScene->mNumMaterials); ASSIMP_LOG_DEBUG("M3D: importMaterials ", mScene->mNumMaterials);
// add a default material as first // add a default material as first
aiMaterial *mat = new aiMaterial; aiMaterial *defaultMat = new aiMaterial;
mat->AddProperty(&name, AI_MATKEY_NAME); defaultMat->AddProperty(&name, AI_MATKEY_NAME);
c.a = 1.0f; c.a = 1.0f;
c.b = c.g = c.r = 0.6f; c.b = c.g = c.r = 0.6f;
mat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE); defaultMat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE);
mScene->mMaterials[0] = mat; mScene->mMaterials[0] = defaultMat;
if (!m3d->nummaterial || !m3d->material) { if (!m3d->nummaterial || !m3d->material) {
return; return;
@ -300,12 +300,12 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d) {
m->prop[j].value.textureid < m3d->numtexture && m->prop[j].value.textureid < m3d->numtexture &&
m3d->texture[m->prop[j].value.textureid].name) { m3d->texture[m->prop[j].value.textureid].name) {
name.Set(std::string(std::string(m3d->texture[m->prop[j].value.textureid].name) + ".png")); name.Set(std::string(std::string(m3d->texture[m->prop[j].value.textureid].name) + ".png"));
mat->AddProperty(&name, aiTxProps[k].pKey, aiTxProps[k].type, aiTxProps[k].index); newMat->AddProperty(&name, aiTxProps[k].pKey, aiTxProps[k].type, aiTxProps[k].index);
n = 0; n = 0;
mat->AddProperty(&n, 1, _AI_MATKEY_UVWSRC_BASE, aiProps[k].type, aiProps[k].index); newMat->AddProperty(&n, 1, _AI_MATKEY_UVWSRC_BASE, aiProps[k].type, aiProps[k].index);
} }
} }
mScene->mMaterials[i + 1] = mat; mScene->mMaterials[i + 1] = newMat;
} }
} }

64
code/AssetLib/M3D/M3DWrapper.h
View File

@ -46,6 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef AI_M3DWRAPPER_H_INC #ifndef AI_M3DWRAPPER_H_INC
#define AI_M3DWRAPPER_H_INC #define AI_M3DWRAPPER_H_INC
#if !(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER #if !(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER
#include <memory> #include <memory>
@ -62,41 +63,68 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "m3d.h" #include "m3d.h"
namespace Assimp { namespace Assimp {
class IOSystem; class IOSystem;
/// brief The M3D-Wrapper, provudes c++ access to the data.
class M3DWrapper { class M3DWrapper {
m3d_t *m3d_ = nullptr;
unsigned char *saved_output_ = nullptr;
public: public:
// Construct an empty M3D model /// Construct an empty M3D model
explicit M3DWrapper(); explicit M3DWrapper();
// Construct an M3D model from provided buffer /// Construct an M3D model from provided buffer
// NOTE: The m3d.h SDK function does not mark the data as const. Have assumed it does not write. /// @note The m3d.h SDK function does not mark the data as const. Have assumed it does not write.
// BUG: SECURITY: The m3d.h SDK cannot be informed of the buffer size. BUFFER OVERFLOW IS CERTAIN /// BUG: SECURITY: The m3d.h SDK cannot be informed of the buffer size. BUFFER OVERFLOW IS CERTAIN
explicit M3DWrapper(IOSystem *pIOHandler, const std::vector<unsigned char> &buffer); explicit M3DWrapper(IOSystem *pIOHandler, const std::vector<unsigned char> &buffer);
~M3DWrapper(); /// Theclasss destructor.
~M3DWrapper();
void reset(); /// Will reset the wrapper, all data will become nullptr.
void reset();
// Name // The Name access, empty string returned when no m3d instance.
inline std::string Name() const { std::string Name() const;
if (m3d_) return std::string(m3d_->name);
return std::string();
}
// Execute a save /// Executes a save.
unsigned char *Save(int quality, int flags, unsigned int &size); unsigned char *Save(int quality, int flags, unsigned int &size);
/// Clearer
void ClearSave(); void ClearSave();
inline explicit operator bool() const { return m3d_ != nullptr; } /// True for m3d instance exists.
explicit operator bool() const;
// Allow direct access to M3D API // Allow direct access to M3D API
inline m3d_t *operator->() const { return m3d_; } m3d_t *operator->() const;
inline m3d_t *M3D() const { return m3d_; } m3d_t *M3D() const;
private:
m3d_t *m3d_ = nullptr;
unsigned char *saved_output_ = nullptr;
}; };
inline std::string M3DWrapper::Name() const {
if (nullptr != m3d_) {
if (nullptr != m3d_->name) {
return std::string(m3d_->name);
}
}
return std::string();
}
inline M3DWrapper::operator bool() const {
return m3d_ != nullptr;
}
inline m3d_t *M3DWrapper::operator->() const {
return m3d_;
}
inline m3d_t *M3DWrapper::M3D() const {
return m3d_;
}
} // namespace Assimp } // namespace Assimp
#endif #endif

6
code/AssetLib/M3D/m3d.h
View File

@ -829,7 +829,7 @@ unsigned char *_m3dstbi_zlib_compress(unsigned char *data, int data_len, int *ou
#include <sys/time.h> #include <sys/time.h>
#endif #endif
#if !defined(M3D_NOIMPORTER) #if !defined(M3D_NOIMPORTER)
/* helper functions for the ASCII parser */ /* helper functions for the ASCII parser */
static char *_m3d_findarg(char *s) { static char *_m3d_findarg(char *s) {
while (s && *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n') while (s && *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n')
@ -4516,7 +4516,7 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
} }
if (length) { if (length) {
uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len)); uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
memcpy( length, &v, sizeof(uint32_t)); memcpy( length, &v, sizeof(uint32_t));
len += v; len += v;
} }
out = NULL; out = NULL;
@ -4548,7 +4548,7 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
} }
} }
uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len)); uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
memcpy( length, &v, sizeof(uint32_t)); memcpy( length, &v, sizeof(uint32_t));
len += v; len += v;
out = NULL; out = NULL;
} }

2
code/AssetLib/MD5/MD5Loader.cpp
View File

@ -485,7 +485,7 @@ void MD5Importer::LoadMD5MeshFile() {
} }
MD5::WeightDesc &weightDesc = meshSrc.mWeights[w]; MD5::WeightDesc &weightDesc = meshSrc.mWeights[w];
if (weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON) { if (weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON) {
continue; continue;
} }

4
code/AssetLib/MDC/MDCFileData.h
View File

@ -120,13 +120,13 @@ struct Surface {
, ulFlags() , ulFlags()
, ulNumCompFrames() , ulNumCompFrames()
, ulNumBaseFrames() , ulNumBaseFrames()
, ulNumShaders() , ulNumShaders()
, ulNumVertices() , ulNumVertices()
, ulNumTriangles() , ulNumTriangles()
, ulOffsetTriangles() , ulOffsetTriangles()
, ulOffsetShaders() , ulOffsetShaders()
, ulOffsetTexCoords() , ulOffsetTexCoords()
, ulOffsetBaseVerts() , ulOffsetBaseVerts()
, ulOffsetCompVerts() , ulOffsetCompVerts()
, ulOffsetFrameBaseFrames() , ulOffsetFrameBaseFrames()
, ulOffsetFrameCompFrames() , ulOffsetFrameCompFrames()

4
code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
View File

@ -629,7 +629,7 @@ void HL1MDLLoader::read_meshes() {
+-- bodypart --+-- model -- [mesh index, mesh index, ...] +-- bodypart --+-- model -- [mesh index, mesh index, ...]
| | | |
| +-- model -- [mesh index, mesh index, ...] | +-- model -- [mesh index, mesh index, ...]
| | | |
| ... | ...
| |
|-- bodypart -- ... |-- bodypart -- ...
@ -1298,7 +1298,7 @@ void HL1MDLLoader::read_global_info() {
* @note The structure of this method is taken from HL2 source code. * @note The structure of this method is taken from HL2 source code.
* Although this is from HL2, it's implementation is almost identical * Although this is from HL2, it's implementation is almost identical
* to code found in HL1 SDK. See HL1 and HL2 SDKs for more info. * to code found in HL1 SDK. See HL1 and HL2 SDKs for more info.
* *
* source: * source:
* HL1 source code. * HL1 source code.
* file: studio_render.cpp * file: studio_render.cpp

8
code/AssetLib/MMD/MMDPmxParser.cpp
View File

@ -102,7 +102,7 @@ namespace pmx
const unsigned int targetSize = size * 3; // enough to encode const unsigned int targetSize = size * 3; // enough to encode
char *targetStart = new char[targetSize]; char *targetStart = new char[targetSize];
std::memset(targetStart, 0, targetSize * sizeof(char)); std::memset(targetStart, 0, targetSize * sizeof(char));
utf8::utf16to8( sourceStart, sourceStart + size/2, targetStart ); utf8::utf16to8( sourceStart, sourceStart + size/2, targetStart );
std::string result(targetStart); std::string result(targetStart);
@ -516,13 +516,13 @@ namespace pmx
stream->read((char*) magic, sizeof(char) * 4); stream->read((char*) magic, sizeof(char) * 4);
if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20) if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
{ {
throw DeadlyImportError("MMD: Invalid magic number."); throw DeadlyImportError("MMD: Invalid magic number.");
} }
stream->read((char*) &version, sizeof(float)); stream->read((char*) &version, sizeof(float));
if (version != 2.0f && version != 2.1f) if (version != 2.0f && version != 2.1f)
{ {
throw DeadlyImportError("MMD: Unsupported version (must be 2.0 or 2.1): ", ai_to_string(version)); throw DeadlyImportError("MMD: Unsupported version (must be 2.0 or 2.1): ", ai_to_string(version));
} }
this->setting.Read(stream); this->setting.Read(stream);
this->model_name = ReadString(stream, setting.encoding); this->model_name = ReadString(stream, setting.encoding);

10
code/AssetLib/OFF/OFFLoader.cpp
View File

@ -138,7 +138,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
const char* car = buffer; const char* car = buffer;
const char* end = buffer + mBuffer2.size(); const char* end = buffer + mBuffer2.size();
NextToken(&car, end); NextToken(&car, end);
if (car < end - 2 && car[0] == 'S' && car[1] == 'T') { if (car < end - 2 && car[0] == 'S' && car[1] == 'T') {
hasTexCoord = true; car += 2; hasTexCoord = true; car += 2;
} }
@ -164,7 +164,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
dimensions = 3; dimensions = 3;
hasHomogenous = false; hasHomogenous = false;
NextToken(&car, end); NextToken(&car, end);
// at this point the next token should be an integer number // at this point the next token should be an integer number
if (car >= end - 1 || *car < '0' || *car > '9') { if (car >= end - 1 || *car < '0' || *car > '9') {
throw DeadlyImportError("OFF: Header is invalid"); throw DeadlyImportError("OFF: Header is invalid");
@ -223,7 +223,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect"); ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect");
break; break;
} }
aiVector3D& v = mesh->mVertices[i]; aiVector3D& v = mesh->mVertices[i];
sz = line; sz = line;
// helper array to write a for loop over possible dimension values // helper array to write a for loop over possible dimension values
@ -255,7 +255,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
SkipSpaces(&sz); SkipSpaces(&sz);
fast_atoreal_move<ai_real>(sz,(ai_real&)n.z); fast_atoreal_move<ai_real>(sz,(ai_real&)n.z);
} }
// reading colors is a pain because the specification says it can be // reading colors is a pain because the specification says it can be
// integers or floats, and any number of them between 1 and 4 included, // integers or floats, and any number of them between 1 and 4 included,
// until the next comment or end of line // until the next comment or end of line
@ -321,7 +321,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
++i; ++i;
++faces; ++faces;
} }
// generate the output node graph // generate the output node graph
pScene->mRootNode = new aiNode(); pScene->mRootNode = new aiNode();
pScene->mRootNode->mName.Set("<OFFRoot>"); pScene->mRootNode->mName.Set("<OFFRoot>");

18
code/AssetLib/Obj/ObjExporter.h
View File

@ -67,7 +67,7 @@ public:
~ObjExporter(); ~ObjExporter();
std::string GetMaterialLibName(); std::string GetMaterialLibName();
std::string GetMaterialLibFileName(); std::string GetMaterialLibFileName();
/// public string-streams to write all output into /// public string-streams to write all output into
std::ostringstream mOutput, mOutputMat; std::ostringstream mOutput, mOutputMat;
@ -137,13 +137,13 @@ private:
} }
}; };
struct aiVectorCompare { struct aiVectorCompare {
bool operator() (const aiVector3D& a, const aiVector3D& b) const { bool operator() (const aiVector3D& a, const aiVector3D& b) const {
if(a.x < b.x) return true; if(a.x < b.x) return true;
if(a.x > b.x) return false; if(a.x > b.x) return false;
if(a.y < b.y) return true; if(a.y < b.y) return true;
if(a.y > b.y) return false; if(a.y > b.y) return false;
if(a.z < b.z) return true; if(a.z < b.z) return true;
return false; return false;
} }
}; };
@ -153,7 +153,7 @@ private:
int mNextIndex; int mNextIndex;
typedef std::map<T, int, Compare> dataType; typedef std::map<T, int, Compare> dataType;
dataType vecMap; dataType vecMap;
public: public:
indexMap() indexMap()
: mNextIndex(1) { : mNextIndex(1) {

2
code/AssetLib/Obj/ObjFileImporter.cpp
View File

@ -468,7 +468,7 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model *pModel,
} }
// Copy all vertex colors // Copy all vertex colors
if (!pModel->m_VertexColors.empty()) { if (vertex < pModel->m_VertexColors.size()) {
const aiVector3D &color = pModel->m_VertexColors[vertex]; const aiVector3D &color = pModel->m_VertexColors[vertex];
pMesh->mColors[0][newIndex] = aiColor4D(color.x, color.y, color.z, 1.0); pMesh->mColors[0][newIndex] = aiColor4D(color.x, color.y, color.z, 1.0);
} }

2
code/AssetLib/Obj/ObjFileMtlImporter.cpp
View File

@ -146,7 +146,7 @@ void ObjFileMtlImporter::load() {
++m_DataIt; ++m_DataIt;
ai_real d; ai_real d;
getFloatValue(d); getFloatValue(d);
m_pModel->m_pCurrentMaterial->alpha = static_cast<ai_real>(1.0) - d; m_pModel->m_pCurrentMaterial->alpha = static_cast<ai_real>(1.0) - d;
} }
m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
} break; } break;

2
code/AssetLib/SMD/SMDLoader.cpp
View File

@ -438,7 +438,7 @@ void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) {
pc->mTransformation = bone.sAnim.asKeys[0].matrix; pc->mTransformation = bone.sAnim.asKeys[0].matrix;
} }
if (bone.iParent == static_cast<uint32_t>(-1)) { if (bone.iParent == static_cast<uint32_t>(-1)) {
bone.mOffsetMatrix = pc->mTransformation; bone.mOffsetMatrix = pc->mTransformation;
} else { } else {
bone.mOffsetMatrix = asBones[bone.iParent].mOffsetMatrix * pc->mTransformation; bone.mOffsetMatrix = asBones[bone.iParent].mOffsetMatrix * pc->mTransformation;

4
code/AssetLib/STEPParser/STEPFileReader.cpp
View File

@ -58,13 +58,13 @@ using namespace Assimp;
namespace EXPRESS = STEP::EXPRESS; namespace EXPRESS = STEP::EXPRESS;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = "") std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = std::string())
{ {
return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(line ",line,") ",s) ); return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(line ",line,") ",s) );
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = "") std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = std::string())
{ {
return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(entity #",entity,") ",s)); return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(entity #",entity,") ",s));
} }

8
code/AssetLib/STL/STLExporter.cpp
View File

@ -69,7 +69,7 @@ void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
if (exporter.mOutput.fail()) { if (exporter.mOutput.fail()) {
throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile)); throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
} }
// we're still here - export successfully completed. Write the file. // we're still here - export successfully completed. Write the file.
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt")); std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
if (outfile == nullptr) { if (outfile == nullptr) {
@ -88,7 +88,7 @@ void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene*
if (exporter.mOutput.fail()) { if (exporter.mOutput.fail()) {
throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile)); throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
} }
// we're still here - export successfully completed. Write the file. // we're still here - export successfully completed. Write the file.
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wb")); std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wb"));
if (outfile == nullptr) { if (outfile == nullptr) {
@ -139,9 +139,9 @@ STLExporter::STLExporter(const char* _filename, const aiScene* pScene, bool expo
if (exportPointClouds) { if (exportPointClouds) {
WritePointCloud("Assimp_Pointcloud", pScene ); WritePointCloud("Assimp_Pointcloud", pScene );
return; return;
} }
// Export the assimp mesh // Export the assimp mesh
const std::string name = "AssimpScene"; const std::string name = "AssimpScene";
mOutput << SolidToken << " " << name << endl; mOutput << SolidToken << " " << name << endl;
for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) { for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {

4
code/AssetLib/STL/STLLoader.cpp
View File

@ -372,7 +372,7 @@ void STLImporter::LoadASCIIFile(aiNode *root) {
pMesh->mVertices = new aiVector3D[pMesh->mNumVertices]; pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
for (size_t i=0; i<pMesh->mNumVertices; ++i ) { for (size_t i=0; i<pMesh->mNumVertices; ++i ) {
pMesh->mVertices[i].x = positionBuffer[i].x; pMesh->mVertices[i].x = positionBuffer[i].x;
pMesh->mVertices[i].y = positionBuffer[i].y; pMesh->mVertices[i].y = positionBuffer[i].y;
pMesh->mVertices[i].z = positionBuffer[i].z; pMesh->mVertices[i].z = positionBuffer[i].z;
} }
positionBuffer.clear(); positionBuffer.clear();
@ -382,7 +382,7 @@ void STLImporter::LoadASCIIFile(aiNode *root) {
pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
for (size_t i=0; i<pMesh->mNumVertices; ++i ) { for (size_t i=0; i<pMesh->mNumVertices; ++i ) {
pMesh->mNormals[i].x = normalBuffer[i].x; pMesh->mNormals[i].x = normalBuffer[i].x;
pMesh->mNormals[i].y = normalBuffer[i].y; pMesh->mNormals[i].y = normalBuffer[i].y;
pMesh->mNormals[i].z = normalBuffer[i].z; pMesh->mNormals[i].z = normalBuffer[i].z;
} }
normalBuffer.clear(); normalBuffer.clear();

120
code/AssetLib/Step/StepExporter.cpp
View File

@ -175,12 +175,11 @@ void StepExporter::WriteFile()
fColor.b = 0.8f; fColor.b = 0.8f;
int ind = 100; // the start index to be used int ind = 100; // the start index to be used
int faceEntryLen = 30; // number of entries for a triangle/face std::vector<int> faceEntryLen; // numbers of entries for a triangle/face
// prepare unique (count triangles and vertices) // prepare unique (count triangles and vertices)
VectorIndexUMap uniqueVerts; // use a map to reduce find complexity to log(n) VectorIndexUMap uniqueVerts; // use a map to reduce find complexity to log(n)
VectorIndexUMap::iterator it; VectorIndexUMap::iterator it;
int countFace = 0;
for (unsigned int i=0; i<mScene->mNumMeshes; ++i) for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
{ {
@ -189,7 +188,7 @@ void StepExporter::WriteFile()
{ {
aiFace* face = &(mesh->mFaces[j]); aiFace* face = &(mesh->mFaces[j]);
if (face->mNumIndices == 3) countFace++; if (face->mNumIndices >= 3) faceEntryLen.push_back(15 + 5 * face->mNumIndices);
} }
for (unsigned int j=0; j<mesh->mNumVertices; ++j) for (unsigned int j=0; j<mesh->mNumVertices; ++j)
{ {
@ -218,10 +217,13 @@ void StepExporter::WriteFile()
// write the top of data // write the top of data
mOutput << "DATA" << endstr; mOutput << "DATA" << endstr;
mOutput << "#1=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(' ',("; mOutput << "#1=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(' ',(";
for (int i=0; i<countFace; ++i) size_t countFace = faceEntryLen.size();
size_t faceLenIndex = ind + 2 * uniqueVerts.size();
for (size_t i=0; i<countFace; ++i)
{ {
mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size(); mOutput << "#" << faceLenIndex;
if (i!=countFace-1) mOutput << ","; if (i!=countFace-1) mOutput << ",";
faceLenIndex += faceEntryLen[i];
} }
mOutput << "),#6)" << endstr; mOutput << "),#6)" << endstr;
@ -253,10 +255,12 @@ void StepExporter::WriteFile()
mOutput << "#27=DIRECTION('',(1.0,0.0,0.0))" << endstr; mOutput << "#27=DIRECTION('',(1.0,0.0,0.0))" << endstr;
mOutput << "#28= (NAMED_UNIT(#21)LENGTH_UNIT()SI_UNIT(.MILLI.,.METRE.))" << endstr; mOutput << "#28= (NAMED_UNIT(#21)LENGTH_UNIT()SI_UNIT(.MILLI.,.METRE.))" << endstr;
mOutput << "#29=CLOSED_SHELL('',("; mOutput << "#29=CLOSED_SHELL('',(";
for (int i=0; i<countFace; ++i) faceLenIndex = ind + 2 * uniqueVerts.size() + 8;
for (size_t i=0; i<countFace; ++i)
{ {
mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size() + 8; mOutput << "#" << faceLenIndex;
if (i!=countFace-1) mOutput << ","; if (i!=countFace-1) mOutput << ",";
faceLenIndex += faceEntryLen[i];
} }
mOutput << "))" << endstr; mOutput << "))" << endstr;
@ -289,28 +293,29 @@ void StepExporter::WriteFile()
{ {
aiFace* face = &(mesh->mFaces[j]); aiFace* face = &(mesh->mFaces[j]);
if (face->mNumIndices != 3) continue; const int numIndices = face->mNumIndices;
if (numIndices < 3) continue;
aiVector3D* v1 = &(mesh->mVertices[face->mIndices[0]]); std::vector<int> pidArray(numIndices, -1); // vertex id
aiVector3D* v2 = &(mesh->mVertices[face->mIndices[1]]); std::vector<aiVector3D> dvArray(numIndices); // edge dir
aiVector3D* v3 = &(mesh->mVertices[face->mIndices[2]]); for (int k = 0; k < numIndices; ++k)
aiVector3D dv12 = *v2 - *v1; {
aiVector3D dv23 = *v3 - *v2; aiVector3D *v1 = &(mesh->mVertices[face->mIndices[k]]);
aiVector3D dv31 = *v1 - *v3; pidArray[k] = uniqueVerts.find(v1)->second;
aiVector3D dv13 = *v3 - *v1;
dv12.Normalize();
dv23.Normalize();
dv31.Normalize();
dv13.Normalize();
aiVector3D dvY = dv12; aiVector3D *v2 = nullptr;
aiVector3D dvX = dvY ^ dv13; if (k + 1 == numIndices)
v2 = &(mesh->mVertices[face->mIndices[0]]);
else
v2 = &(mesh->mVertices[face->mIndices[k + 1]]);
dvArray[k] = *v2 - *v1;
dvArray[k].Normalize();
}
aiVector3D dvY = dvArray[1];
aiVector3D dvX = dvY ^ dvArray[0];
dvX.Normalize(); dvX.Normalize();
int pid1 = uniqueVerts.find(v1)->second;
int pid2 = uniqueVerts.find(v2)->second;
int pid3 = uniqueVerts.find(v3)->second;
// mean vertex color for the face if available // mean vertex color for the face if available
if (mesh->HasVertexColors(0)) if (mesh->HasVertexColors(0))
{ {
@ -339,35 +344,62 @@ void StepExporter::WriteFile()
/* 2 directions of the plane */ /* 2 directions of the plane */
mOutput << "#" << sid+9 << "=PLANE('',#" << sid+10 << ")" << endstr; mOutput << "#" << sid+9 << "=PLANE('',#" << sid+10 << ")" << endstr;
mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pid1 << ", #" << sid+11 << ",#" << sid+12 << ")" << endstr; mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pidArray[0] << ",#" << sid+11 << ",#" << sid+12 << ")" << endstr;
mOutput << "#" << sid + 11 << "=DIRECTION('',(" << dvX.x << "," << dvX.y << "," << dvX.z << "))" << endstr; mOutput << "#" << sid + 11 << "=DIRECTION('',(" << dvX.x << "," << dvX.y << "," << dvX.z << "))" << endstr;
mOutput << "#" << sid + 12 << "=DIRECTION('',(" << dvY.x << "," << dvY.y << "," << dvY.z << "))" << endstr; mOutput << "#" << sid + 12 << "=DIRECTION('',(" << dvY.x << "," << dvY.y << "," << dvY.z << "))" << endstr;
mOutput << "#" << sid+13 << "=FACE_BOUND('',#" << sid+14 << ",.T.)" << endstr; mOutput << "#" << sid+13 << "=FACE_BOUND('',#" << sid+14 << ",.T.)" << endstr;
mOutput << "#" << sid+14 << "=EDGE_LOOP('',(#" << sid+15 << ",#" << sid+16 << ",#" << sid+17 << "))" << endstr; mOutput << "#" << sid+14 << "=EDGE_LOOP('',(";
int edgeLoopStart = sid + 15;
for (int k = 0; k < numIndices; ++k)
{
if (k == 0)
mOutput << "#";
else
mOutput << ",#";
mOutput << edgeLoopStart + k;
}
mOutput << "))" << endstr;
/* edge loop */ /* edge loop */
mOutput << "#" << sid+15 << "=ORIENTED_EDGE('',*,*,#" << sid+18 << ",.T.)" << endstr; int orientedEdgesStart = edgeLoopStart + numIndices;
mOutput << "#" << sid+16 << "=ORIENTED_EDGE('',*,*,#" << sid+19 << ",.T.)" << endstr; for (int k=0; k < numIndices; k++)
mOutput << "#" << sid+17 << "=ORIENTED_EDGE('',*,*,#" << sid+20 << ",.T.)" << endstr; {
mOutput << "#" << edgeLoopStart+k << "=ORIENTED_EDGE('',*,*,#" << orientedEdgesStart + k << ",.T.)" << endstr;
}
/* oriented edges */ /* oriented edges */
mOutput << "#" << sid+18 << "=EDGE_CURVE('',#" << pid1+1 << ",#" << pid2+1 << ",#" << sid+21 << ",.F.)" << endstr; int lineStart = orientedEdgesStart + numIndices;
mOutput << "#" << sid+19 << "=EDGE_CURVE('',#" << pid2+1 << ",#" << pid3+1 << ",#" << sid+22 << ",.T.)" << endstr; for (int k=0; k < numIndices; ++k)
mOutput << "#" << sid+20 << "=EDGE_CURVE('',#" << pid3+1 << ",#" << pid1+1 << ",#" << sid+23 << ",.T.)" << endstr; {
if (k == 0)
mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[k+1]+1 << ",#" << lineStart+k << ",.F.)" << endstr;
else if (k+1 == numIndices)
mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[0]+1 << ",#" << lineStart+k << ",.T.)" << endstr;
else
mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[k+1]+1 << ",#" << lineStart+k << ",.T.)" << endstr;
}
/* 3 lines and 3 vectors for the lines for the 3 edge curves */ /* n lines and n vectors for the lines for the n edge curves */
mOutput << "#" << sid+21 << "=LINE('',#" << pid1 << ",#" << sid+24 << ")" << endstr; int vectorStart = lineStart + numIndices;
mOutput << "#" << sid+22 << "=LINE('',#" << pid2 << ",#" << sid+25 << ")" << endstr; for (int k=0; k < numIndices; ++k)
mOutput << "#" << sid+23 << "=LINE('',#" << pid3 << ",#" << sid+26 << ")" << endstr; {
mOutput << "#" << sid+24 << "=VECTOR('',#" << sid+27 << ",1.0)" << endstr; mOutput << "#" << lineStart+k << "=LINE('',#" << pidArray[k] << ",#" << vectorStart+k << ")" << endstr;
mOutput << "#" << sid+25 << "=VECTOR('',#" << sid+28 << ",1.0)" << endstr; }
mOutput << "#" << sid+26 << "=VECTOR('',#" << sid+29 << ",1.0)" << endstr;
mOutput << "#" << sid+27 << "=DIRECTION('',(" << dv12.x << "," << dv12.y << "," << dv12.z << "))" << endstr; int directionStart = vectorStart + numIndices;
mOutput << "#" << sid+28 << "=DIRECTION('',(" << dv23.x << "," << dv23.y << "," << dv23.z << "))" << endstr; for (int k=0; k < numIndices; ++k)
mOutput << "#" << sid+29 << "=DIRECTION('',(" << dv31.x << "," << dv31.y << "," << dv31.z << "))" << endstr; {
ind += faceEntryLen; // increase counter mOutput << "#" << vectorStart+k << "=VECTOR('',#" << directionStart+k << ",1.0)" << endstr;
}
for (int k=0; k < numIndices; ++k)
{
const aiVector3D &dv = dvArray[k];
mOutput << "#" << directionStart + k << "=DIRECTION('',(" << dv.x << "," << dv.y << "," << dv.z << "))" << endstr;
}
ind += 15 + 5*numIndices; // increase counter
} }
} }

2
code/AssetLib/X/XFileExporter.cpp
View File

@ -86,7 +86,7 @@ void ExportSceneXFile(const char* pFile,IOSystem* pIOSystem, const aiScene* pSce
if (iDoTheExportThing.mOutput.fail()) { if (iDoTheExportThing.mOutput.fail()) {
throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile)); throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
} }
// we're still here - export successfully completed. Write result to the given IOSYstem // we're still here - export successfully completed. Write result to the given IOSYstem
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt")); std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
if (outfile == nullptr) { if (outfile == nullptr) {

6
code/AssetLib/X/XFileExporter.h
View File

@ -94,9 +94,9 @@ protected:
void PushTag() { startstr.append( " "); } void PushTag() { startstr.append( " "); }
/// Leaves an element, decreasing the indentation /// Leaves an element, decreasing the indentation
void PopTag() { void PopTag() {
ai_assert( startstr.length() > 1); ai_assert( startstr.length() > 1);
startstr.erase( startstr.length() - 2); startstr.erase( startstr.length() - 2);
} }
public: public:

4
code/AssetLib/X/XFileImporter.cpp
View File

@ -667,9 +667,7 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
// convert to lower case for easier comparison // convert to lower case for easier comparison
for ( unsigned int c = 0; c < sz.length(); ++c ) { for ( unsigned int c = 0; c < sz.length(); ++c ) {
if ( isalpha( (unsigned char) sz[ c ] ) ) { sz[ c ] = (char) tolower( (unsigned char) sz[ c ] );
sz[ c ] = (char) tolower( (unsigned char) sz[ c ] );
}
} }
// Place texture filename property under the corresponding name // Place texture filename property under the corresponding name

2
code/AssetLib/X3D/X3DImporter.cpp
View File

@ -180,6 +180,6 @@ const aiImporterDesc *X3DImporter::GetInfo() const {
return &Description; return &Description;
} }
} }
#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER #endif // !ASSIMP_BUILD_NO_X3D_IMPORTER

2
code/AssetLib/XGL/XGLLoader.cpp
View File

@ -240,7 +240,7 @@ void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) { void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) {
for (XmlNode &currentNode : node.children()) { for (XmlNode &currentNode : node.children()) {
const std::string &s = ai_stdStrToLower(currentNode.name()); const std::string &s = ai_stdStrToLower(currentNode.name());
// XXX right now we'd skip <lighting> if it comes after // XXX right now we'd skip <lighting> if it comes after
// <object> or <mesh> // <object> or <mesh>
if (s == "lighting") { if (s == "lighting") {

2
code/AssetLib/glTF/glTFCommon.h
View File

@ -196,7 +196,7 @@ inline std::string getCurrentAssetDir(const std::string &pFile) {
std::string path = pFile; std::string path = pFile;
int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\'))); int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\')));
if (pos == int(std::string::npos)) { if (pos == int(std::string::npos)) {
return ""; return std::string();
} }
return pFile.substr(0, pos + 1); return pFile.substr(0, pos + 1);

1
code/AssetLib/glTF/glTFExporter.cpp
View File

@ -526,6 +526,7 @@ void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buf
#if defined(__has_warning) #if defined(__has_warning)
#if __has_warning("-Wunused-but-set-variable") #if __has_warning("-Wunused-but-set-variable")
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-but-set-variable" #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif #endif
#endif #endif

4
code/AssetLib/glTF2/glTF2Asset.h
View File

@ -388,9 +388,9 @@ struct CustomExtension {
} }
CustomExtension() = default; CustomExtension() = default;
~CustomExtension() = default; ~CustomExtension() = default;
CustomExtension(const CustomExtension &other) : CustomExtension(const CustomExtension &other) :
name(other.name), name(other.name),
mStringValue(other.mStringValue), mStringValue(other.mStringValue),

34
code/AssetLib/glTF2/glTF2Asset.inl
View File

@ -410,14 +410,14 @@ inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Prim
// Not same size, convert // Not same size, convert
switch (componentBytes) { switch (componentBytes) {
case sizeof(uint32_t): case sizeof(uint32_t):
CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh); CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh);
break; break;
case sizeof(uint16_t): case sizeof(uint16_t):
CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh); CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh);
break; break;
case sizeof(uint8_t): case sizeof(uint8_t):
CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh); CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh);
break; break;
default: default:
ai_assert(false); ai_assert(false);
@ -460,23 +460,23 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes); decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes);
switch (accessor.componentType) { switch (accessor.componentType) {
case ComponentType_BYTE: case ComponentType_BYTE:
GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
break; break;
case ComponentType_UNSIGNED_BYTE: case ComponentType_UNSIGNED_BYTE:
GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
break; break;
case ComponentType_SHORT: case ComponentType_SHORT:
GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
break; break;
case ComponentType_UNSIGNED_SHORT: case ComponentType_UNSIGNED_SHORT:
GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
break; break;
case ComponentType_UNSIGNED_INT: case ComponentType_UNSIGNED_INT:
GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
break; break;
case ComponentType_FLOAT: case ComponentType_FLOAT:
GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
break; break;
default: default:
ai_assert(false); ai_assert(false);
@ -840,7 +840,7 @@ inline bool Buffer::ReplaceData_joint(const size_t pBufferData_Offset, const siz
inline size_t Buffer::AppendData(uint8_t *data, size_t length) { inline size_t Buffer::AppendData(uint8_t *data, size_t length) {
const size_t offset = this->byteLength; const size_t offset = this->byteLength;
// Force alignment to 4 bits // Force alignment to 4 bits
const size_t paddedLength = (length + 3) & ~3; const size_t paddedLength = (length + 3) & ~3;
Grow(paddedLength); Grow(paddedLength);
@ -1522,7 +1522,7 @@ inline bool GetAttribTargetVector(Mesh::Primitive &p, const int targetIndex, con
inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) { inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
Value *curName = FindMember(pJSON_Object, "name"); Value *curName = FindMember(pJSON_Object, "name");
if (nullptr != curName) { if (nullptr != curName && curName->IsString()) {
name = curName->GetString(); name = curName->GetString();
} }

16
code/AssetLib/glTF2/glTF2AssetWriter.inl
View File

@ -452,7 +452,7 @@ namespace glTF2 {
WriteTex(materialClearcoat, clearcoat.clearcoatTexture, "clearcoatTexture", w.mAl); WriteTex(materialClearcoat, clearcoat.clearcoatTexture, "clearcoatTexture", w.mAl);
WriteTex(materialClearcoat, clearcoat.clearcoatRoughnessTexture, "clearcoatRoughnessTexture", w.mAl); WriteTex(materialClearcoat, clearcoat.clearcoatRoughnessTexture, "clearcoatRoughnessTexture", w.mAl);
WriteTex(materialClearcoat, clearcoat.clearcoatNormalTexture, "clearcoatNormalTexture", w.mAl); WriteTex(materialClearcoat, clearcoat.clearcoatNormalTexture, "clearcoatNormalTexture", w.mAl);
if (!materialClearcoat.ObjectEmpty()) { if (!materialClearcoat.ObjectEmpty()) {
exts.AddMember("KHR_materials_clearcoat", materialClearcoat, w.mAl); exts.AddMember("KHR_materials_clearcoat", materialClearcoat, w.mAl);
} }
@ -468,7 +468,7 @@ namespace glTF2 {
} }
WriteTex(materialTransmission, transmission.transmissionTexture, "transmissionTexture", w.mAl); WriteTex(materialTransmission, transmission.transmissionTexture, "transmissionTexture", w.mAl);
if (!materialTransmission.ObjectEmpty()) { if (!materialTransmission.ObjectEmpty()) {
exts.AddMember("KHR_materials_transmission", materialTransmission, w.mAl); exts.AddMember("KHR_materials_transmission", materialTransmission, w.mAl);
} }
@ -613,7 +613,7 @@ namespace glTF2 {
if (n.skin) { if (n.skin) {
obj.AddMember("skin", n.skin->index, w.mAl); obj.AddMember("skin", n.skin->index, w.mAl);
} }
//gltf2 spec does not support "skeletons" under node //gltf2 spec does not support "skeletons" under node
if(n.skeletons.size()) { if(n.skeletons.size()) {
AddRefsVector(obj, "skeletons", n.skeletons, w.mAl); AddRefsVector(obj, "skeletons", n.skeletons, w.mAl);
@ -711,7 +711,7 @@ namespace glTF2 {
if (mAsset.scene) { if (mAsset.scene) {
mDoc.AddMember("scene", mAsset.scene->index, mAl); mDoc.AddMember("scene", mAsset.scene->index, mAl);
} }
if(mAsset.extras) { if(mAsset.extras) {
mDoc.AddMember("extras", *mAsset.extras, mAl); mDoc.AddMember("extras", *mAsset.extras, mAl);
} }
@ -812,7 +812,7 @@ namespace glTF2 {
uint32_t binaryChunkLength = 0; uint32_t binaryChunkLength = 0;
if (bodyBuffer->byteLength > 0) { if (bodyBuffer->byteLength > 0) {
binaryChunkLength = (bodyBuffer->byteLength + 3) & ~3; // Round up to next multiple of 4 binaryChunkLength = (bodyBuffer->byteLength + 3) & ~3; // Round up to next multiple of 4
auto curPaddingLength = binaryChunkLength - bodyBuffer->byteLength; auto curPaddingLength = binaryChunkLength - bodyBuffer->byteLength;
++GLB_Chunk_count; ++GLB_Chunk_count;
@ -881,7 +881,7 @@ namespace glTF2 {
if (this->mAsset.extensionsUsed.KHR_materials_sheen) { if (this->mAsset.extensionsUsed.KHR_materials_sheen) {
exts.PushBack(StringRef("KHR_materials_sheen"), mAl); exts.PushBack(StringRef("KHR_materials_sheen"), mAl);
} }
if (this->mAsset.extensionsUsed.KHR_materials_clearcoat) { if (this->mAsset.extensionsUsed.KHR_materials_clearcoat) {
exts.PushBack(StringRef("KHR_materials_clearcoat"), mAl); exts.PushBack(StringRef("KHR_materials_clearcoat"), mAl);
} }
@ -893,7 +893,7 @@ namespace glTF2 {
if (this->mAsset.extensionsUsed.FB_ngon_encoding) { if (this->mAsset.extensionsUsed.FB_ngon_encoding) {
exts.PushBack(StringRef("FB_ngon_encoding"), mAl); exts.PushBack(StringRef("FB_ngon_encoding"), mAl);
} }
if (this->mAsset.extensionsUsed.KHR_texture_basisu) { if (this->mAsset.extensionsUsed.KHR_texture_basisu) {
exts.PushBack(StringRef("KHR_texture_basisu"), mAl); exts.PushBack(StringRef("KHR_texture_basisu"), mAl);
} }
@ -901,7 +901,7 @@ namespace glTF2 {
if (!exts.Empty()) if (!exts.Empty())
mDoc.AddMember("extensionsUsed", exts, mAl); mDoc.AddMember("extensionsUsed", exts, mAl);
//basisu extensionRequired //basisu extensionRequired
Value extsReq; Value extsReq;
extsReq.SetArray(); extsReq.SetArray();

14
code/AssetLib/glTF2/glTF2Importer.cpp
View File

@ -992,8 +992,8 @@ void ParseExtensions(aiMetadata *metadata, const CustomExtension &extension) {
metadata->Add(extension.name.c_str(), extension.mBoolValue.value); metadata->Add(extension.name.c_str(), extension.mBoolValue.value);
} else if (extension.mValues.isPresent) { } else if (extension.mValues.isPresent) {
aiMetadata val; aiMetadata val;
for (size_t i = 0; i < extension.mValues.value.size(); ++i) { for (auto const & subExtension : extension.mValues.value) {
ParseExtensions(&val, extension.mValues.value[i]); ParseExtensions(&val, subExtension);
} }
metadata->Add(extension.name.c_str(), val); metadata->Add(extension.name.c_str(), val);
} }
@ -1001,8 +1001,8 @@ void ParseExtensions(aiMetadata *metadata, const CustomExtension &extension) {
void ParseExtras(aiMetadata *metadata, const CustomExtension &extension) { void ParseExtras(aiMetadata *metadata, const CustomExtension &extension) {
if (extension.mValues.isPresent) { if (extension.mValues.isPresent) {
for (size_t i = 0; i < extension.mValues.value.size(); ++i) { for (auto const & subExtension : extension.mValues.value) {
ParseExtensions(metadata, extension.mValues.value[i]); ParseExtensions(metadata, subExtension);
} }
} }
} }
@ -1336,6 +1336,12 @@ std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation &an
continue; continue;
} }
auto& animsampler = anim.samplers[channel.sampler];
if (animsampler.input->count > animsampler.output->count) {
ASSIMP_LOG_WARN("Animation ", anim.name, ": Number of keyframes in sampler input ", animsampler.input->count, " exceeds number of keyframes in sampler output ", animsampler.output->count);
continue;
}
const unsigned int node_index = channel.target.node.GetIndex(); const unsigned int node_index = channel.target.node.GetIndex();
AnimationSamplers &sampler = samplers[node_index]; AnimationSamplers &sampler = samplers[node_index];

13
code/Common/Assimp.cpp
View File

@ -72,12 +72,25 @@ namespace Assimp {
// underlying structure for aiPropertyStore // underlying structure for aiPropertyStore
typedef BatchLoader::PropertyMap PropertyMap; typedef BatchLoader::PropertyMap PropertyMap;
#if defined(__has_warning)
#if __has_warning("-Wordered-compare-function-pointers")
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wordered-compare-function-pointers"
#endif
#endif
/** Stores the LogStream objects for all active C log streams */ /** Stores the LogStream objects for all active C log streams */
struct mpred { struct mpred {
bool operator()(const aiLogStream &s0, const aiLogStream &s1) const { bool operator()(const aiLogStream &s0, const aiLogStream &s1) const {
return s0.callback < s1.callback && s0.user < s1.user; return s0.callback < s1.callback && s0.user < s1.user;
} }
}; };
#if defined(__has_warning)
#if __has_warning("-Wordered-compare-function-pointers")
#pragma GCC diagnostic pop
#endif
#endif
typedef std::map<aiLogStream, Assimp::LogStream *, mpred> LogStreamMap; typedef std::map<aiLogStream, Assimp::LogStream *, mpred> LogStreamMap;
/** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */ /** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */

6
code/Common/DefaultIOStream.cpp
View File

@ -62,7 +62,7 @@ inline int select_fseek(FILE *file, int64_t offset, int origin) {
} }
#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601) #if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
template <> template <>
inline size_t select_ftell<8>(FILE *file) { inline size_t select_ftell<8>(FILE *file) {
@ -75,7 +75,7 @@ inline int select_fseek<8>(FILE *file, int64_t offset, int origin) {
} }
#endif // #if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601) #endif // #if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
} // namespace } // namespace
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -95,7 +95,7 @@ size_t DefaultIOStream::Read(void *pvBuffer,
} }
ai_assert(nullptr != pvBuffer); ai_assert(nullptr != pvBuffer);
ai_assert(0 != pSize); ai_assert(0 != pSize);
return (mFile ? ::fread(pvBuffer, pSize, pCount, mFile) : 0); return (mFile ? ::fread(pvBuffer, pSize, pCount, mFile) : 0);
} }

6
code/Common/DefaultIOSystem.cpp
View File

@ -71,7 +71,7 @@ static std::wstring Utf8ToWide(const char *in) {
// size includes terminating null; std::wstring adds null automatically // size includes terminating null; std::wstring adds null automatically
std::wstring out(static_cast<size_t>(size) - 1, L'\0'); std::wstring out(static_cast<size_t>(size) - 1, L'\0');
MultiByteToWideChar(CP_UTF8, 0, in, -1, &out[0], size); MultiByteToWideChar(CP_UTF8, 0, in, -1, &out[0], size);
return out; return out;
} }
@ -85,7 +85,7 @@ static std::string WideToUtf8(const wchar_t *in) {
// size includes terminating null; std::string adds null automatically // size includes terminating null; std::string adds null automatically
std::string out(static_cast<size_t>(size) - 1, '\0'); std::string out(static_cast<size_t>(size) - 1, '\0');
WideCharToMultiByte(CP_UTF8, 0, in, -1, &out[0], size, nullptr, nullptr); WideCharToMultiByte(CP_UTF8, 0, in, -1, &out[0], size, nullptr, nullptr);
return out; return out;
} }
#endif #endif
@ -121,7 +121,7 @@ IOStream *DefaultIOSystem::Open(const char *strFile, const char *strMode) {
if (name.empty()) { if (name.empty()) {
return nullptr; return nullptr;
} }
file = ::_wfopen(name.c_str(), Utf8ToWide(strMode).c_str()); file = ::_wfopen(name.c_str(), Utf8ToWide(strMode).c_str());
#else #else
file = ::fopen(strFile, strMode); file = ::fopen(strFile, strMode);

4
code/Common/Exporter.cpp
View File

@ -83,7 +83,7 @@ namespace Assimp {
void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out); void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Exporter worker function prototypes. Do not use const, because some exporter need to convert // Exporter worker function prototypes. Do not use const, because some exporter need to convert
// the scene temporary // the scene temporary
#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER #ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
void ExportSceneCollada(const char*,IOSystem*, const aiScene*, const ExportProperties*); void ExportSceneCollada(const char*,IOSystem*, const aiScene*, const ExportProperties*);
@ -343,7 +343,7 @@ const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const cha
delete pimpl->blob; delete pimpl->blob;
pimpl->blob = nullptr; pimpl->blob = nullptr;
} }
auto baseName = pProperties ? pProperties->GetPropertyString(AI_CONFIG_EXPORT_BLOB_NAME, AI_BLOBIO_MAGIC) : AI_BLOBIO_MAGIC; auto baseName = pProperties ? pProperties->GetPropertyString(AI_CONFIG_EXPORT_BLOB_NAME, AI_BLOBIO_MAGIC) : AI_BLOBIO_MAGIC;
std::shared_ptr<IOSystem> old = pimpl->mIOSystem; std::shared_ptr<IOSystem> old = pimpl->mIOSystem;

4
code/Common/FileSystemFilter.h
View File

@ -101,7 +101,7 @@ public:
/** Tests for the existence of a file at the given path. */ /** Tests for the existence of a file at the given path. */
bool Exists( const char* pFile) const { bool Exists( const char* pFile) const {
ai_assert( nullptr != mWrapped ); ai_assert( nullptr != mWrapped );
std::string tmp = pFile; std::string tmp = pFile;
// Currently this IOSystem is also used to open THE ONE FILE. // Currently this IOSystem is also used to open THE ONE FILE.
@ -126,7 +126,7 @@ public:
if ( nullptr == pFile || nullptr == pMode ) { if ( nullptr == pFile || nullptr == pMode ) {
return nullptr; return nullptr;
} }
ai_assert( nullptr != pFile ); ai_assert( nullptr != pFile );
ai_assert( nullptr != pMode ); ai_assert( nullptr != pMode );

80
code/Common/Importer.cpp
View File

@ -201,7 +201,7 @@ Importer::~Importer() {
// Register a custom post-processing step // Register a custom post-processing step
aiReturn Importer::RegisterPPStep(BaseProcess* pImp) { aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
ai_assert( nullptr != pImp ); ai_assert( nullptr != pImp );
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
pimpl->mPostProcessingSteps.push_back(pImp); pimpl->mPostProcessingSteps.push_back(pImp);
@ -215,7 +215,7 @@ aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
// Register a custom loader plugin // Register a custom loader plugin
aiReturn Importer::RegisterLoader(BaseImporter* pImp) { aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
ai_assert(nullptr != pImp); ai_assert(nullptr != pImp);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
// -------------------------------------------------------------------- // --------------------------------------------------------------------
@ -242,7 +242,7 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
pimpl->mImporter.push_back(pImp); pimpl->mImporter.push_back(pImp);
ASSIMP_LOG_INFO("Registering custom importer for these file extensions: ", baked); ASSIMP_LOG_INFO("Registering custom importer for these file extensions: ", baked);
ASSIMP_END_EXCEPTION_REGION(aiReturn); ASSIMP_END_EXCEPTION_REGION(aiReturn);
return AI_SUCCESS; return AI_SUCCESS;
} }
@ -296,7 +296,7 @@ aiReturn Importer::UnregisterPPStep(BaseProcess* pImp) {
// Supplies a custom IO handler to the importer to open and access files. // Supplies a custom IO handler to the importer to open and access files.
void Importer::SetIOHandler( IOSystem* pIOHandler) { void Importer::SetIOHandler( IOSystem* pIOHandler) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
// If the new handler is zero, allocate a default IO implementation. // If the new handler is zero, allocate a default IO implementation.
if (!pIOHandler) { if (!pIOHandler) {
@ -315,7 +315,7 @@ void Importer::SetIOHandler( IOSystem* pIOHandler) {
// Get the currently set IO handler // Get the currently set IO handler
IOSystem* Importer::GetIOHandler() const { IOSystem* Importer::GetIOHandler() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return pimpl->mIOHandler; return pimpl->mIOHandler;
} }
@ -323,7 +323,7 @@ IOSystem* Importer::GetIOHandler() const {
// Check whether a custom IO handler is currently set // Check whether a custom IO handler is currently set
bool Importer::IsDefaultIOHandler() const { bool Importer::IsDefaultIOHandler() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return pimpl->mIsDefaultHandler; return pimpl->mIsDefaultHandler;
} }
@ -331,9 +331,9 @@ bool Importer::IsDefaultIOHandler() const {
// Supplies a custom progress handler to get regular callbacks during importing // Supplies a custom progress handler to get regular callbacks during importing
void Importer::SetProgressHandler ( ProgressHandler* pHandler ) { void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
// If the new handler is zero, allocate a default implementation. // If the new handler is zero, allocate a default implementation.
if (!pHandler) { if (!pHandler) {
// Release pointer in the possession of the caller // Release pointer in the possession of the caller
@ -351,7 +351,7 @@ void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
// Get the currently set progress handler // Get the currently set progress handler
ProgressHandler* Importer::GetProgressHandler() const { ProgressHandler* Importer::GetProgressHandler() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return pimpl->mProgressHandler; return pimpl->mProgressHandler;
} }
@ -359,7 +359,7 @@ ProgressHandler* Importer::GetProgressHandler() const {
// Check whether a custom progress handler is currently set // Check whether a custom progress handler is currently set
bool Importer::IsDefaultProgressHandler() const { bool Importer::IsDefaultProgressHandler() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return pimpl->mIsDefaultProgressHandler; return pimpl->mIsDefaultProgressHandler;
} }
@ -381,7 +381,7 @@ bool _ValidateFlags(unsigned int pFlags) {
// Free the current scene // Free the current scene
void Importer::FreeScene( ) { void Importer::FreeScene( ) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
delete pimpl->mScene; delete pimpl->mScene;
@ -396,14 +396,14 @@ void Importer::FreeScene( ) {
// Get the current error string, if any // Get the current error string, if any
const char* Importer::GetErrorString() const { const char* Importer::GetErrorString() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
// Must remain valid as long as ReadFile() or FreeFile() are not called // Must remain valid as long as ReadFile() or FreeFile() are not called
return pimpl->mErrorString.c_str(); return pimpl->mErrorString.c_str();
} }
const std::exception_ptr& Importer::GetException() const { const std::exception_ptr& Importer::GetException() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
// Must remain valid as long as ReadFile() or FreeFile() are not called // Must remain valid as long as ReadFile() or FreeFile() are not called
return pimpl->mException; return pimpl->mException;
} }
@ -412,7 +412,7 @@ const std::exception_ptr& Importer::GetException() const {
// Enable extra-verbose mode // Enable extra-verbose mode
void Importer::SetExtraVerbose(bool bDo) { void Importer::SetExtraVerbose(bool bDo) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
pimpl->bExtraVerbose = bDo; pimpl->bExtraVerbose = bDo;
} }
@ -420,7 +420,7 @@ void Importer::SetExtraVerbose(bool bDo) {
// Get the current scene // Get the current scene
const aiScene* Importer::GetScene() const { const aiScene* Importer::GetScene() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return pimpl->mScene; return pimpl->mScene;
} }
@ -428,7 +428,7 @@ const aiScene* Importer::GetScene() const {
// Orphan the current scene and return it. // Orphan the current scene and return it.
aiScene* Importer::GetOrphanedScene() { aiScene* Importer::GetOrphanedScene() {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
aiScene* s = pimpl->mScene; aiScene* s = pimpl->mScene;
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
@ -437,7 +437,7 @@ aiScene* Importer::GetOrphanedScene() {
pimpl->mErrorString = std::string(); pimpl->mErrorString = std::string();
pimpl->mException = std::exception_ptr(); pimpl->mException = std::exception_ptr();
ASSIMP_END_EXCEPTION_REGION(aiScene*); ASSIMP_END_EXCEPTION_REGION(aiScene*);
return s; return s;
} }
@ -487,7 +487,7 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
unsigned int pFlags, unsigned int pFlags,
const char* pHint /*= ""*/) { const char* pHint /*= ""*/) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
if (!pHint) { if (!pHint) {
pHint = ""; pHint = "";
@ -518,7 +518,7 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void WriteLogOpening(const std::string& file) { void WriteLogOpening(const std::string& file) {
ASSIMP_LOG_INFO("Load ", file); ASSIMP_LOG_INFO("Load ", file);
// print a full version dump. This is nice because we don't // print a full version dump. This is nice because we don't
@ -580,7 +580,7 @@ void WriteLogOpening(const std::string& file) {
// Reads the given file and returns its contents if successful. // Reads the given file and returns its contents if successful.
const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) { const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
const std::string pFile(_pFile); const std::string pFile(_pFile);
@ -745,7 +745,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
// either successful or failure - the pointer expresses it anyways // either successful or failure - the pointer expresses it anyways
ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException); ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException);
return pimpl->mScene; return pimpl->mScene;
} }
@ -754,7 +754,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
// Apply post-processing to the currently bound scene // Apply post-processing to the currently bound scene
const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) { const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
// Return immediately if no scene is active // Return immediately if no scene is active
if (!pimpl->mScene) { if (!pimpl->mScene) {
@ -832,7 +832,7 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
} }
#endif // ! DEBUG #endif // ! DEBUG
} }
pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()), pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()),
static_cast<int>(pimpl->mPostProcessingSteps.size()) ); static_cast<int>(pimpl->mPostProcessingSteps.size()) );
// update private scene flags // update private scene flags
@ -845,14 +845,14 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
ASSIMP_LOG_INFO("Leaving post processing pipeline"); ASSIMP_LOG_INFO("Leaving post processing pipeline");
ASSIMP_END_EXCEPTION_REGION(const aiScene*); ASSIMP_END_EXCEPTION_REGION(const aiScene*);
return pimpl->mScene; return pimpl->mScene;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) { const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
// Return immediately if no scene is active // Return immediately if no scene is active
@ -934,14 +934,14 @@ bool Importer::IsExtensionSupported(const char* szExtension) const {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
size_t Importer::GetImporterCount() const { size_t Importer::GetImporterCount() const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return pimpl->mImporter.size(); return pimpl->mImporter.size();
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const aiImporterDesc* Importer::GetImporterInfo(size_t index) const { const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
if (index >= pimpl->mImporter.size()) { if (index >= pimpl->mImporter.size()) {
return nullptr; return nullptr;
} }
@ -952,7 +952,7 @@ const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
BaseImporter* Importer::GetImporter (size_t index) const { BaseImporter* Importer::GetImporter (size_t index) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
if (index >= pimpl->mImporter.size()) { if (index >= pimpl->mImporter.size()) {
return nullptr; return nullptr;
} }
@ -963,7 +963,7 @@ BaseImporter* Importer::GetImporter (size_t index) const {
// Find a loader plugin for a given file extension // Find a loader plugin for a given file extension
BaseImporter* Importer::GetImporter (const char* szExtension) const { BaseImporter* Importer::GetImporter (const char* szExtension) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return GetImporter(GetImporterIndex(szExtension)); return GetImporter(GetImporterIndex(szExtension));
} }
@ -1002,7 +1002,7 @@ size_t Importer::GetImporterIndex (const char* szExtension) const {
// Helper function to build a list of all file extensions supported by ASSIMP // Helper function to build a list of all file extensions supported by ASSIMP
void Importer::GetExtensionList(aiString& szOut) const { void Importer::GetExtensionList(aiString& szOut) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
std::set<std::string> str; std::set<std::string> str;
for (std::vector<BaseImporter*>::const_iterator i = pimpl->mImporter.begin();i != pimpl->mImporter.end();++i) { for (std::vector<BaseImporter*>::const_iterator i = pimpl->mImporter.begin();i != pimpl->mImporter.end();++i) {
@ -1028,7 +1028,7 @@ void Importer::GetExtensionList(aiString& szOut) const {
// Set a configuration property // Set a configuration property
bool Importer::SetPropertyInteger(const char* szName, int iValue) { bool Importer::SetPropertyInteger(const char* szName, int iValue) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
bool existing; bool existing;
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue); existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
@ -1040,7 +1040,7 @@ bool Importer::SetPropertyInteger(const char* szName, int iValue) {
// Set a configuration property // Set a configuration property
bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) { bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
bool existing; bool existing;
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
existing = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue); existing = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue);
@ -1052,7 +1052,7 @@ bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
// Set a configuration property // Set a configuration property
bool Importer::SetPropertyString(const char* szName, const std::string& value) { bool Importer::SetPropertyString(const char* szName, const std::string& value) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
bool existing; bool existing;
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
existing = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value); existing = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);
@ -1064,7 +1064,7 @@ bool Importer::SetPropertyString(const char* szName, const std::string& value) {
// Set a configuration property // Set a configuration property
bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) { bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
bool existing; bool existing;
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
existing = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value); existing = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
@ -1076,7 +1076,7 @@ bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
// Get a configuration property // Get a configuration property
int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const { int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn); return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn);
} }
@ -1084,7 +1084,7 @@ int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffff
// Get a configuration property // Get a configuration property
ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const { ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn); return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn);
} }
@ -1092,7 +1092,7 @@ ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*=
// Get a configuration property // Get a configuration property
std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const { std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn); return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn);
} }
@ -1100,13 +1100,13 @@ std::string Importer::GetPropertyString(const char* szName, const std::string& i
// Get a configuration property // Get a configuration property
aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const { aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn); return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Get the memory requirements of a single node // Get the memory requirements of a single node
inline inline
void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) { void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
if ( nullptr == pcNode ) { if ( nullptr == pcNode ) {
return; return;
@ -1124,7 +1124,7 @@ void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
// Get the memory requirements of the scene // Get the memory requirements of the scene
void Importer::GetMemoryRequirements(aiMemoryInfo& in) const { void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
ai_assert(nullptr != pimpl); ai_assert(nullptr != pimpl);
in = aiMemoryInfo(); in = aiMemoryInfo();
aiScene* mScene = pimpl->mScene; aiScene* mScene = pimpl->mScene;

6
code/Common/Importer.h
View File

@ -183,7 +183,7 @@ public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Construct a batch loader from a given IO system to be used /** Construct a batch loader from a given IO system to be used
* to access external files * to access external files
*/ */
explicit BatchLoader(IOSystem* pIO, bool validate = false ); explicit BatchLoader(IOSystem* pIO, bool validate = false );
@ -197,13 +197,13 @@ public:
* @param enable True for validation. * @param enable True for validation.
*/ */
void setValidation( bool enabled ); void setValidation( bool enabled );
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns the current validation step. /** Returns the current validation step.
* @return The current validation step. * @return The current validation step.
*/ */
bool getValidation() const; bool getValidation() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Add a new file to the list of files to be loaded. /** Add a new file to the list of files to be loaded.
* @param file File to be loaded * @param file File to be loaded

4
code/Common/ImporterRegistry.cpp
View File

@ -205,8 +205,8 @@ corresponding preprocessor flag to selectively disable formats.
namespace Assimp { namespace Assimp {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void GetImporterInstanceList(std::vector<BaseImporter *> &out) { void GetImporterInstanceList(std::vector<BaseImporter *> &out) {
// Some importers may be unimplemented or otherwise unsuitable for general use // Some importers may be unimplemented or otherwise unsuitable for general use
// in their current state. Devs can set ASSIMP_ENABLE_DEV_IMPORTERS in their // in their current state. Devs can set ASSIMP_ENABLE_DEV_IMPORTERS in their
// local environment to enable them, otherwise they're left out of the registry. // local environment to enable them, otherwise they're left out of the registry.

7
code/Common/RemoveComments.cpp
View File

@ -59,13 +59,16 @@ void CommentRemover::RemoveLineComments(const char* szComment,
ai_assert(nullptr != szBuffer); ai_assert(nullptr != szBuffer);
ai_assert(*szComment); ai_assert(*szComment);
const size_t len = strlen(szComment); size_t len = strlen(szComment);
const size_t lenBuffer = strlen(szBuffer);
if (len > lenBuffer) {
len = lenBuffer;
}
while (*szBuffer) { while (*szBuffer) {
// skip over quotes // skip over quotes
if (*szBuffer == '\"' || *szBuffer == '\'') if (*szBuffer == '\"' || *szBuffer == '\'')
while (*szBuffer++ && *szBuffer != '\"' && *szBuffer != '\''); while (*szBuffer++ && *szBuffer != '\"' && *szBuffer != '\'');
if (!strncmp(szBuffer,szComment,len)) { if (!strncmp(szBuffer,szComment,len)) {
while (!IsLineEnd(*szBuffer)) while (!IsLineEnd(*szBuffer))
*szBuffer++ = chReplacement; *szBuffer++ = chReplacement;

8
code/Common/Win32DebugLogStream.h
View File

@ -71,19 +71,19 @@ public:
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline inline
Win32DebugLogStream::Win32DebugLogStream(){ Win32DebugLogStream::Win32DebugLogStream(){
// empty // empty
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline inline
Win32DebugLogStream::~Win32DebugLogStream(){ Win32DebugLogStream::~Win32DebugLogStream(){
// empty // empty
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline inline
void Win32DebugLogStream::write(const char* message) { void Win32DebugLogStream::write(const char* message) {
::OutputDebugStringA( message); ::OutputDebugStringA( message);
} }

2
code/PostProcessing/ArmaturePopulate.h
View File

@ -97,7 +97,7 @@ public:
static void BuildBoneList(aiNode *current_node, const aiNode *root_node, static void BuildBoneList(aiNode *current_node, const aiNode *root_node,
const aiScene *scene, const aiScene *scene,
std::vector<aiBone *> &bones); std::vector<aiBone *> &bones);
static void BuildBoneStack(aiNode *current_node, const aiNode *root_node, static void BuildBoneStack(aiNode *current_node, const aiNode *root_node,
const aiScene *scene, const aiScene *scene,

2
code/PostProcessing/DropFaceNormalsProcess.cpp
View File

@ -104,7 +104,7 @@ bool DropFaceNormalsProcess::DropMeshFaceNormals (aiMesh* mesh) {
if (nullptr == mesh->mNormals) { if (nullptr == mesh->mNormals) {
return false; return false;
} }
delete[] mesh->mNormals; delete[] mesh->mNormals;
mesh->mNormals = nullptr; mesh->mNormals = nullptr;
return true; return true;

2
code/PostProcessing/EmbedTexturesProcess.cpp
View File

@ -137,7 +137,7 @@ bool EmbedTexturesProcess::addTexture(aiScene *pScene, const std::string &path)
pScene->mTextures = new aiTexture*[pScene->mNumTextures]; pScene->mTextures = new aiTexture*[pScene->mNumTextures];
::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u)); ::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u));
delete [] oldTextures; delete [] oldTextures;
// Add the new texture // Add the new texture
auto pTexture = new aiTexture; auto pTexture = new aiTexture;
pTexture->mHeight = 0; // Means that this is still compressed pTexture->mHeight = 0; // Means that this is still compressed

2
code/PostProcessing/FindDegenerates.cpp
View File

@ -90,7 +90,7 @@ void FindDegeneratesProcess::Execute( aiScene* pScene) {
if ( nullptr == pScene) { if ( nullptr == pScene) {
return; return;
} }
std::unordered_map<unsigned int, unsigned int> meshMap; std::unordered_map<unsigned int, unsigned int> meshMap;
meshMap.reserve(pScene->mNumMeshes); meshMap.reserve(pScene->mNumMeshes);

2
code/PostProcessing/FindInstancesProcess.cpp
View File

@ -137,7 +137,7 @@ void FindInstancesProcess::Execute( aiScene* pScene)
aiMesh* inst = pScene->mMeshes[i]; aiMesh* inst = pScene->mMeshes[i];
hashes[i] = GetMeshHash(inst); hashes[i] = GetMeshHash(inst);
// Find an appropriate epsilon // Find an appropriate epsilon
// to compare position differences against // to compare position differences against
float epsilon = ComputePositionEpsilon(inst); float epsilon = ComputePositionEpsilon(inst);
epsilon *= epsilon; epsilon *= epsilon;

2
code/PostProcessing/MakeVerboseFormat.h
View File

@ -98,7 +98,7 @@ public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Checks whether the scene is already in verbose format. /** Checks whether the scene is already in verbose format.
* @param pScene The data to check. * @param pScene The data to check.
* @return true if the scene is already in verbose format. */ * @return true if the scene is already in verbose format. */
static bool IsVerboseFormat(const aiScene* pScene); static bool IsVerboseFormat(const aiScene* pScene);

2
code/PostProcessing/RemoveRedundantMaterials.cpp
View File

@ -215,7 +215,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
} }
else else
{ {
ASSIMP_LOG_INFO("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ", ASSIMP_LOG_INFO("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ",
unreferencedRemoved, " unused materials."); unreferencedRemoved, " unused materials.");
} }
} }

38
code/PostProcessing/ScaleProcess.cpp
View File

@ -75,7 +75,7 @@ void ScaleProcess::SetupProperties( const Importer* pImp ) {
// File scaling * Application Scaling // File scaling * Application Scaling
float importerScale = pImp->GetPropertyFloat( AI_CONFIG_APP_SCALE_KEY, 1.0f ); float importerScale = pImp->GetPropertyFloat( AI_CONFIG_APP_SCALE_KEY, 1.0f );
// apply scale to the scale // apply scale to the scale
// helps prevent bugs with backward compatibility for anyone using normal scaling. // helps prevent bugs with backward compatibility for anyone using normal scaling.
mScale *= importerScale; mScale *= importerScale;
} }
@ -84,7 +84,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
if(mScale == 1.0f) { if(mScale == 1.0f) {
return; // nothing to scale return; // nothing to scale
} }
ai_assert( mScale != 0 ); ai_assert( mScale != 0 );
ai_assert( nullptr != pScene ); ai_assert( nullptr != pScene );
ai_assert( nullptr != pScene->mRootNode ); ai_assert( nullptr != pScene->mRootNode );
@ -96,7 +96,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
if ( nullptr == pScene->mRootNode ) { if ( nullptr == pScene->mRootNode ) {
return; return;
} }
// Process animations and update position transform to new unit system // Process animations and update position transform to new unit system
for( unsigned int animationID = 0; animationID < pScene->mNumAnimations; animationID++ ) for( unsigned int animationID = 0; animationID < pScene->mNumAnimations; animationID++ )
{ {
@ -105,7 +105,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
for( unsigned int animationChannel = 0; animationChannel < animation->mNumChannels; animationChannel++) for( unsigned int animationChannel = 0; animationChannel < animation->mNumChannels; animationChannel++)
{ {
aiNodeAnim* anim = animation->mChannels[animationChannel]; aiNodeAnim* anim = animation->mChannels[animationChannel];
for( unsigned int posKey = 0; posKey < anim->mNumPositionKeys; posKey++) for( unsigned int posKey = 0; posKey < anim->mNumPositionKeys; posKey++)
{ {
aiVectorKey& vectorKey = anim->mPositionKeys[posKey]; aiVectorKey& vectorKey = anim->mPositionKeys[posKey];
@ -116,8 +116,8 @@ void ScaleProcess::Execute( aiScene* pScene ) {
for( unsigned int meshID = 0; meshID < pScene->mNumMeshes; meshID++) for( unsigned int meshID = 0; meshID < pScene->mNumMeshes; meshID++)
{ {
aiMesh *mesh = pScene->mMeshes[meshID]; aiMesh *mesh = pScene->mMeshes[meshID];
// Reconstruct mesh vertexes to the new unit system // Reconstruct mesh vertexes to the new unit system
for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++) for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++)
{ {
@ -129,9 +129,9 @@ void ScaleProcess::Execute( aiScene* pScene ) {
// bone placement / scaling // bone placement / scaling
for( unsigned int boneID = 0; boneID < mesh->mNumBones; boneID++) for( unsigned int boneID = 0; boneID < mesh->mNumBones; boneID++)
{ {
// Reconstruct matrix by transform rather than by scale // Reconstruct matrix by transform rather than by scale
// This prevent scale values being changed which can // This prevent scale values being changed which can
// be meaningful in some cases // be meaningful in some cases
// like when you want the modeller to see 1:1 compatibility. // like when you want the modeller to see 1:1 compatibility.
aiBone* bone = mesh->mBones[boneID]; aiBone* bone = mesh->mBones[boneID];
@ -139,10 +139,10 @@ void ScaleProcess::Execute( aiScene* pScene ) {
aiQuaternion rotation; aiQuaternion rotation;
bone->mOffsetMatrix.Decompose( scale, rotation, pos); bone->mOffsetMatrix.Decompose( scale, rotation, pos);
aiMatrix4x4 translation; aiMatrix4x4 translation;
aiMatrix4x4::Translation( pos * mScale, translation ); aiMatrix4x4::Translation( pos * mScale, translation );
aiMatrix4x4 scaling; aiMatrix4x4 scaling;
aiMatrix4x4::Scaling( aiVector3D(scale), scaling ); aiMatrix4x4::Scaling( aiVector3D(scale), scaling );
@ -157,7 +157,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
for( unsigned int animMeshID = 0; animMeshID < mesh->mNumAnimMeshes; animMeshID++) for( unsigned int animMeshID = 0; animMeshID < mesh->mNumAnimMeshes; animMeshID++)
{ {
aiAnimMesh * animMesh = mesh->mAnimMeshes[animMeshID]; aiAnimMesh * animMesh = mesh->mAnimMeshes[animMeshID];
for( unsigned int vertexID = 0; vertexID < animMesh->mNumVertices; vertexID++) for( unsigned int vertexID = 0; vertexID < animMesh->mNumVertices; vertexID++)
{ {
aiVector3D& vertex = animMesh->mVertices[vertexID]; aiVector3D& vertex = animMesh->mVertices[vertexID];
@ -169,31 +169,31 @@ void ScaleProcess::Execute( aiScene* pScene ) {
traverseNodes( pScene->mRootNode ); traverseNodes( pScene->mRootNode );
} }
void ScaleProcess::traverseNodes( aiNode *node, unsigned int nested_node_id ) { void ScaleProcess::traverseNodes( aiNode *node, unsigned int nested_node_id ) {
applyScaling( node ); applyScaling( node );
for( size_t i = 0; i < node->mNumChildren; i++) for( size_t i = 0; i < node->mNumChildren; i++)
{ {
// recurse into the tree until we are done! // recurse into the tree until we are done!
traverseNodes( node->mChildren[i], nested_node_id+1 ); traverseNodes( node->mChildren[i], nested_node_id+1 );
} }
} }
void ScaleProcess::applyScaling( aiNode *currentNode ) { void ScaleProcess::applyScaling( aiNode *currentNode ) {
if ( nullptr != currentNode ) { if ( nullptr != currentNode ) {
// Reconstruct matrix by transform rather than by scale // Reconstruct matrix by transform rather than by scale
// This prevent scale values being changed which can // This prevent scale values being changed which can
// be meaningful in some cases // be meaningful in some cases
// like when you want the modeller to // like when you want the modeller to
// see 1:1 compatibility. // see 1:1 compatibility.
aiVector3D pos, scale; aiVector3D pos, scale;
aiQuaternion rotation; aiQuaternion rotation;
currentNode->mTransformation.Decompose( scale, rotation, pos); currentNode->mTransformation.Decompose( scale, rotation, pos);
aiMatrix4x4 translation; aiMatrix4x4 translation;
aiMatrix4x4::Translation( pos * mScale, translation ); aiMatrix4x4::Translation( pos * mScale, translation );
aiMatrix4x4 scaling; aiMatrix4x4 scaling;
// note: we do not use mScale here, this is on purpose. // note: we do not use mScale here, this is on purpose.

4
code/PostProcessing/ScaleProcess.h
View File

@ -55,8 +55,8 @@ namespace Assimp {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** ScaleProcess: Class to rescale the whole model. /** ScaleProcess: Class to rescale the whole model.
* Now rescales animations, bones, and blend shapes properly. * Now rescales animations, bones, and blend shapes properly.
* Please note this will not write to 'scale' transform it will rewrite mesh * Please note this will not write to 'scale' transform it will rewrite mesh
* and matrixes so that your scale values * and matrixes so that your scale values
* from your model package are preserved, so this is completely intentional * from your model package are preserved, so this is completely intentional
* bugs should be reported as soon as they are found. * bugs should be reported as soon as they are found.
*/ */

12
code/PostProcessing/SplitByBoneCountProcess.cpp
View File

@ -209,7 +209,7 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
// a small local set of new bones for the current face. State of all used bones for that face // a small local set of new bones for the current face. State of all used bones for that face
// can only be updated AFTER the face is completely analysed. Thanks to imre for the fix. // can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
std::set<unsigned int> newBonesAtCurrentFace; std::set<unsigned int> newBonesAtCurrentFace;
const aiFace& face = pMesh->mFaces[a]; const aiFace& face = pMesh->mFaces[a];
// check every vertex if its bones would still fit into the current submesh // check every vertex if its bones would still fit into the current submesh
for( unsigned int b = 0; b < face.mNumIndices; ++b ) for( unsigned int b = 0; b < face.mNumIndices; ++b )
@ -221,7 +221,7 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
if( !isBoneUsed[boneIndex] ) if( !isBoneUsed[boneIndex] )
{ {
newBonesAtCurrentFace.insert(boneIndex); newBonesAtCurrentFace.insert(boneIndex);
} }
} }
} }
@ -412,7 +412,7 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
if (pMesh->mNumAnimMeshes > 0) { if (pMesh->mNumAnimMeshes > 0) {
newMesh->mNumAnimMeshes = pMesh->mNumAnimMeshes; newMesh->mNumAnimMeshes = pMesh->mNumAnimMeshes;
newMesh->mAnimMeshes = new aiAnimMesh*[newMesh->mNumAnimMeshes]; newMesh->mAnimMeshes = new aiAnimMesh*[newMesh->mNumAnimMeshes];
for (unsigned int morphIdx = 0; morphIdx < newMesh->mNumAnimMeshes; ++morphIdx) { for (unsigned int morphIdx = 0; morphIdx < newMesh->mNumAnimMeshes; ++morphIdx) {
aiAnimMesh* origTarget = pMesh->mAnimMeshes[morphIdx]; aiAnimMesh* origTarget = pMesh->mAnimMeshes[morphIdx];
aiAnimMesh* newTarget = new aiAnimMesh; aiAnimMesh* newTarget = new aiAnimMesh;
@ -421,16 +421,16 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
newTarget->mNumVertices = numSubMeshVertices; newTarget->mNumVertices = numSubMeshVertices;
newTarget->mVertices = new aiVector3D[numSubMeshVertices]; newTarget->mVertices = new aiVector3D[numSubMeshVertices];
newMesh->mAnimMeshes[morphIdx] = newTarget; newMesh->mAnimMeshes[morphIdx] = newTarget;
if (origTarget->HasNormals()) { if (origTarget->HasNormals()) {
newTarget->mNormals = new aiVector3D[numSubMeshVertices]; newTarget->mNormals = new aiVector3D[numSubMeshVertices];
} }
if (origTarget->HasTangentsAndBitangents()) { if (origTarget->HasTangentsAndBitangents()) {
newTarget->mTangents = new aiVector3D[numSubMeshVertices]; newTarget->mTangents = new aiVector3D[numSubMeshVertices];
newTarget->mBitangents = new aiVector3D[numSubMeshVertices]; newTarget->mBitangents = new aiVector3D[numSubMeshVertices];
} }
for( unsigned int vi = 0; vi < numSubMeshVertices; ++vi) { for( unsigned int vi = 0; vi < numSubMeshVertices; ++vi) {
// find the source vertex for it in the source mesh // find the source vertex for it in the source mesh
unsigned int previousIndex = previousVertexIndices[vi]; unsigned int previousIndex = previousVertexIndices[vi];

4
code/PostProcessing/SplitLargeMeshes.cpp
View File

@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** /**
* @file Implementation of the SplitLargeMeshes postprocessing step * @file Implementation of the SplitLargeMeshes postprocessing step
*/ */
@ -353,7 +353,7 @@ void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene) {
std::vector<std::pair<aiMesh*, unsigned int> > avList; std::vector<std::pair<aiMesh*, unsigned int> > avList;
//Check for point cloud first, //Check for point cloud first,
//Do not process point cloud, splitMesh works only with faces data //Do not process point cloud, splitMesh works only with faces data
for (unsigned int a = 0; a < pScene->mNumMeshes; a++) { for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
if ( pScene->mMeshes[a]->mPrimitiveTypes == aiPrimitiveType_POINT ) { if ( pScene->mMeshes[a]->mPrimitiveTypes == aiPrimitiveType_POINT ) {

2
code/PostProcessing/TextureTransform.cpp
View File

@ -448,7 +448,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) { if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
ASSIMP_LOG_ERROR(static_cast<unsigned int>(trafo.size()), " UV channels required but just ", ASSIMP_LOG_ERROR(static_cast<unsigned int>(trafo.size()), " UV channels required but just ",
AI_MAX_NUMBER_OF_TEXTURECOORDS, " available"); AI_MAX_NUMBER_OF_TEXTURECOORDS, " available");
} }
size = AI_MAX_NUMBER_OF_TEXTURECOORDS; size = AI_MAX_NUMBER_OF_TEXTURECOORDS;

12
code/PostProcessing/TriangulateProcess.cpp
View File

@ -86,11 +86,11 @@ namespace {
/** /**
* @brief Encode the current triangle, and make sure it is recognized as a triangle. * @brief Encode the current triangle, and make sure it is recognized as a triangle.
* *
* This method will rotate indices in tri if needed in order to avoid tri to be considered * This method will rotate indices in tri if needed in order to avoid tri to be considered
* part of the previous ngon. This method is to be used whenever you want to emit a real triangle, * part of the previous ngon. This method is to be used whenever you want to emit a real triangle,
* and make sure it is seen as a triangle. * and make sure it is seen as a triangle.
* *
* @param tri Triangle to encode. * @param tri Triangle to encode.
*/ */
void ngonEncodeTriangle(aiFace * tri) { void ngonEncodeTriangle(aiFace * tri) {
@ -108,10 +108,10 @@ namespace {
/** /**
* @brief Encode a quad (2 triangles) in ngon encoding, and make sure they are seen as a single ngon. * @brief Encode a quad (2 triangles) in ngon encoding, and make sure they are seen as a single ngon.
* *
* @param tri1 First quad triangle * @param tri1 First quad triangle
* @param tri2 Second quad triangle * @param tri2 Second quad triangle
* *
* @pre Triangles must be properly fanned from the most appropriate vertex. * @pre Triangles must be properly fanned from the most appropriate vertex.
*/ */
void ngonEncodeQuad(aiFace *tri1, aiFace *tri2) { void ngonEncodeQuad(aiFace *tri1, aiFace *tri2) {
@ -140,7 +140,7 @@ namespace {
/** /**
* @brief Check whether this triangle would be considered part of the lastly emitted ngon or not. * @brief Check whether this triangle would be considered part of the lastly emitted ngon or not.
* *
* @param tri Current triangle. * @param tri Current triangle.
* @return true If used as is, this triangle will be part of last ngon. * @return true If used as is, this triangle will be part of last ngon.
* @return false If used as is, this triangle is not considered part of the last ngon. * @return false If used as is, this triangle is not considered part of the last ngon.
@ -512,7 +512,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
num = 0; num = 0;
break; break;
/*curOut -= (max-num); // undo all previous work /*curOut -= (max-num); // undo all previous work
for (tmp = 0; tmp < max-2; ++tmp) { for (tmp = 0; tmp < max-2; ++tmp) {
aiFace& nface = *curOut++; aiFace& nface = *curOut++;

3
contrib/openddlparser/code/OpenDDLExport.cpp
View File

@ -134,10 +134,9 @@ bool OpenDDLExport::writeToStream(const std::string &statement) {
} }
bool OpenDDLExport::writeNode(DDLNode *node, std::string &statement) { bool OpenDDLExport::writeNode(DDLNode *node, std::string &statement) {
bool success(true);
writeNodeHeader(node, statement); writeNodeHeader(node, statement);
if (node->hasProperties()) { if (node->hasProperties()) {
success |= writeProperties(node, statement); writeProperties(node, statement);
} }
writeLineEnd(statement); writeLineEnd(statement);

30
contrib/openddlparser/code/OpenDDLParser.cpp
View File

@ -132,6 +132,24 @@ OpenDDLParser::~OpenDDLParser() {
clear(); clear();
} }
void OpenDDLParser::logToStream(FILE *f, LogSeverity severity, const std::string &message) {
if (f) {
const char *tag = "none";
switch (severity) {
case ddl_debug_msg: tag = "debug"; break;
case ddl_info_msg: tag = "info"; break;
case ddl_warn_msg: tag = "warn"; break;
case ddl_error_msg: tag = "error"; break;
}
fprintf(f, "OpenDDLParser: (%5s) %s\n", tag, message.c_str());
}
}
OpenDDLParser::logCallback OpenDDLParser::StdLogCallback (FILE *destination) {
using namespace std::placeholders;
return std::bind(logToStream, destination ? destination : stderr, _1, _2);
}
void OpenDDLParser::setLogCallback(logCallback callback) { void OpenDDLParser::setLogCallback(logCallback callback) {
// install user-specific log callback; null = no log callback // install user-specific log callback; null = no log callback
m_logCallback = callback; m_logCallback = callback;
@ -171,12 +189,8 @@ size_t OpenDDLParser::getBufferSize() const {
void OpenDDLParser::clear() { void OpenDDLParser::clear() {
m_buffer.resize(0); m_buffer.resize(0);
if (nullptr != m_context) { delete m_context;
delete m_context; m_context = nullptr;
m_context = nullptr;
}
// DDLNode::releaseNodes();
} }
bool OpenDDLParser::validate() { bool OpenDDLParser::validate() {
@ -506,7 +520,9 @@ char *OpenDDLParser::parseName(char *in, char *end, Name **name) {
in = parseIdentifier(in, end, &id); in = parseIdentifier(in, end, &id);
if (id) { if (id) {
currentName = new Name(ntype, id); currentName = new Name(ntype, id);
*name = currentName; if (currentName) {
*name = currentName;
}
} }
return in; return in;

9
contrib/openddlparser/code/Value.cpp
View File

@ -113,13 +113,14 @@ Value::~Value() {
if (m_data != nullptr) { if (m_data != nullptr) {
if (m_type == ValueType::ddl_ref) { if (m_type == ValueType::ddl_ref) {
Reference *tmp = (Reference *)m_data; Reference *tmp = (Reference *)m_data;
if (tmp != nullptr) if (tmp != nullptr) {
delete tmp; delete tmp;
} else }
} else {
delete[] m_data; delete[] m_data;
}
} }
if (m_next != nullptr) delete m_next;
delete m_next;
} }
void Value::setBool(bool value) { void Value::setBool(bool value) {

13
contrib/openddlparser/include/openddlparser/OpenDDLParser.h
View File

@ -29,6 +29,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <string> #include <string>
#include <vector> #include <vector>
#include <functional>
BEGIN_ODDLPARSER_NS BEGIN_ODDLPARSER_NS
@ -97,8 +98,8 @@ DLL_ODDLPARSER_EXPORT const char *getTypeToken(Value::ValueType type);
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
class DLL_ODDLPARSER_EXPORT OpenDDLParser { class DLL_ODDLPARSER_EXPORT OpenDDLParser {
public: public:
/// @brief The log callback function pointer. /// @brief The log callback function.
typedef void (*logCallback)(LogSeverity severity, const std::string &msg); typedef std::function<void (LogSeverity severity, const std::string &msg)> logCallback;
public: public:
/// @brief The default class constructor. /// @brief The default class constructor.
@ -120,6 +121,11 @@ public:
/// @return The current log callback. /// @return The current log callback.
logCallback getLogCallback() const; logCallback getLogCallback() const;
/// @brief A default log callback that writes to a FILE.
/// @param destination [in] Output stream. NULL will use stderr.
/// @return A callback that you can pass to setLogCallback.
static logCallback StdLogCallback(FILE *destination = nullptr);
/// @brief Assigns a new buffer to parse. /// @brief Assigns a new buffer to parse.
/// @param buffer [in] The buffer /// @param buffer [in] The buffer
/// @param len [in] Size of the buffer /// @param len [in] Size of the buffer
@ -192,6 +198,9 @@ private:
typedef std::vector<DDLNode *> DDLNodeStack; typedef std::vector<DDLNode *> DDLNodeStack;
DDLNodeStack m_stack; DDLNodeStack m_stack;
Context *m_context; Context *m_context;
/// @brief Callback for StdLogCallback(). Not meant to be called directly.
static void logToStream (FILE *, LogSeverity, const std::string &);
}; };
END_ODDLPARSER_NS END_ODDLPARSER_NS

18
doc/dox.h
View File

@ -90,8 +90,8 @@ but not all of them are *open-source*. If there's an accompagning '<file>\source
@section main_install Installation @section main_install Installation
assimp can be used in two ways: linking against the pre-built libraries or building the library on your own. The former assimp can be used in two ways: linking against the pre-built libraries or building the library on your own. The former
option is the easiest, but the assimp distribution contains pre-built libraries only for Visual C++ 2013, 2015 and 2017. option is the easiest, but the assimp distribution contains pre-built libraries only for Visual C++ 2013, 2015 and 2017.
For other compilers you'll have to build assimp for yourself. Which is hopefully as hassle-free as the other way, but For other compilers you'll have to build assimp for yourself. Which is hopefully as hassle-free as the other way, but
needs a bit more work. Both ways are described at the @link install Installation page. @endlink needs a bit more work. Both ways are described at the @link install Installation page. @endlink
If you want to use assimp on Ubuntu you can install it via the following command: If you want to use assimp on Ubuntu you can install it via the following command:
@ -145,7 +145,7 @@ to your include paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&g
and the assimp/lib/&lt;Compiler&gt; path to your linker paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&gt;VC++ Directories-&gt;Library files). and the assimp/lib/&lt;Compiler&gt; path to your linker paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&gt;VC++ Directories-&gt;Library files).
This is necessary only once to setup all paths inside you IDE. This is necessary only once to setup all paths inside you IDE.
To use the library in your C++ project you can simply generate a project file via cmake. One way is to add the assimp-folder To use the library in your C++ project you can simply generate a project file via cmake. One way is to add the assimp-folder
as a subdirectory via the cmake-command as a subdirectory via the cmake-command
@code @code
@ -158,7 +158,7 @@ Now just add the assimp-dependency to your application:
TARGET_LINK_LIBRARIES(my_game assimp) TARGET_LINK_LIBRARIES(my_game assimp)
@endcode @endcode
If done correctly you should now be able to compile, link, run and use the application. If done correctly you should now be able to compile, link, run and use the application.
@section install_own Building the library from scratch @section install_own Building the library from scratch
@ -170,7 +170,7 @@ to build the library just open a command-prompt / bash, navigate into the repo-f
cmake CMakeLists.txt cmake CMakeLists.txt
@endcode @endcode
A project-file of your default make-system ( like gnu-make on linux or Visual-Studio on Windows ) will be generated. A project-file of your default make-system ( like gnu-make on linux or Visual-Studio on Windows ) will be generated.
Run the build and you are done. You can find the libs at assimp/lib and the dll's / so's at bin. Run the build and you are done. You can find the libs at assimp/lib and the dll's / so's at bin.
@section assimp_dll Windows DLL Build @section assimp_dll Windows DLL Build
@ -496,10 +496,10 @@ X3 Y3 Z3 T3
@endcode @endcode
with <tt>(X1, X2, X3)</tt> being the local X base vector, <tt>(Y1, Y2, Y3)</tt> being the local with <tt>(X1, X2, X3)</tt> being the local X base vector, <tt>(Y1, Y2, Y3)</tt> being the local
Y base vector, <tt>(Z1, Z2, Z3)</tt> being the local Z base vector and <tt>(T1, T2, T3)</tt> being the Y base vector, <tt>(Z1, Z2, Z3)</tt> being the local Z base vector and <tt>(T1, T2, T3)</tt> being the
offset of the local origin (the translational part). offset of the local origin (the translational part).
All matrices in the library use row-major storage order. That means that the matrix elements are All matrices in the library use row-major storage order. That means that the matrix elements are
stored row-by-row, i.e. they end up like this in memory: stored row-by-row, i.e. they end up like this in memory:
<tt>[X1, Y1, Z1, T1, X2, Y2, Z2, T2, X3, Y3, Z3, T3, 0, 0, 0, 1]</tt>. <tt>[X1, Y1, Z1, T1, X2, Y2, Z2, T2, X3, Y3, Z3, T3, 0, 0, 0, 1]</tt>.
Note that this is neither the OpenGL format nor the DirectX format, because both of them specify the Note that this is neither the OpenGL format nor the DirectX format, because both of them specify the
matrix layout such that the translational part occupies three consecutive addresses in memory (so those matrix layout such that the translational part occupies three consecutive addresses in memory (so those
@ -1498,7 +1498,7 @@ Just copy'n'paste the template from Appendix A and adapt it for your needs.
with DefaultLogger::get()->[error, warn, debug, info]. with DefaultLogger::get()->[error, warn, debug, info].
</li> </li>
<li> <li>
Make sure that your loader compiles against all build configurations on all supported platforms. You can use our CI-build to check several platforms Make sure that your loader compiles against all build configurations on all supported platforms. You can use our CI-build to check several platforms
like Windows and Linux ( 32 bit and 64 bit ). like Windows and Linux ( 32 bit and 64 bit ).
</li> </li>
<li> <li>

38
doc/dox_cmd.h
View File

@ -12,7 +12,7 @@
@section intro Introduction @section intro Introduction
This document describes the usage of assimp's command line tools. This document describes the usage of assimp's command line tools.
This is *not* the SDK reference and programming-related stuff is not covered here. This is *not* the SDK reference and programming-related stuff is not covered here.
<br><br> <br><br>
<b>NOTE</b>: For simplicity, the following sections are written with Windows in mind. However <b>NOTE</b>: For simplicity, the following sections are written with Windows in mind. However
@ -29,7 +29,7 @@ assimp [command] [parameters]
The following commands are available: The following commands are available:
<table border="1"> <table border="1">
<tr> <tr>
<td><b>@link version version @endlink</b></td> <td><b>@link version version @endlink</b></td>
<td>Retrieve the current version of assimp</td> <td>Retrieve the current version of assimp</td>
@ -184,7 +184,7 @@ Generate a text or binary dump of a model. This is the core component of Assimp'
regression test suite but it could also be useful for other developers to quickly regression test suite but it could also be useful for other developers to quickly
examine the contents of a model. Note that text dumps are not intended to be used as examine the contents of a model. Note that text dumps are not intended to be used as
intermediate format, Assimp is not able to read them again, nor is the file format intermediate format, Assimp is not able to read them again, nor is the file format
stable or well-defined. It may change with every revision without notice. stable or well-defined. It may change with every revision without notice.
Binary dumps (*.assbin) are backwards- and forwards-compatible. Binary dumps (*.assbin) are backwards- and forwards-compatible.
<h3>Syntax:</h3> <h3>Syntax:</h3>
@ -199,7 +199,7 @@ assimp dump <model> [<out>] [-b] [-s] [common parameters]
<p> <p>
<tt> <tt>
model<br></tt><br> model<br></tt><br>
Required. Relative or absolute path to the input model. Required. Relative or absolute path to the input model.
</p> </p>
<p> <p>
<tt> <tt>
@ -220,7 +220,7 @@ The long form of this parameter is <tt>--binary</tt>.
</tt><br> </tt><br>
Optional. If this switch is specified, the dump is shortened to include only Optional. If this switch is specified, the dump is shortened to include only
min/max values for all vertex components and animation channels. The resulting min/max values for all vertex components and animation channels. The resulting
file is much smaller, but the original model can't be reconstructed from it. This is file is much smaller, but the original model can't be reconstructed from it. This is
used by Assimp's regression test suite, comparing those minidumps provides used by Assimp's regression test suite, comparing those minidumps provides
a fast way to verify whether a loader works correctly or not. a fast way to verify whether a loader works correctly or not.
The long form of this parameter is <tt>--short</tt>. The long form of this parameter is <tt>--short</tt>.
@ -229,7 +229,7 @@ The long form of this parameter is <tt>--short</tt>.
<p> <p>
<tt> <tt>
common parameters<br></tt><br> common parameters<br></tt><br>
Optional. Import configuration & postprocessing. Optional. Import configuration & postprocessing.
See the @link common common parameters page @endlink for more information. See the @link common common parameters page @endlink for more information.
</p> </p>
@ -248,7 +248,7 @@ The log output is included with the dump.
@code @code
assimp dump files\*.* assimp dump files\*.*
assimp dump files\*.* assimp dump files\*.*
@endcode @endcode
Dumps all loadable model files in the 'files' subdir. The output dumps are named Dumps all loadable model files in the 'files' subdir. The output dumps are named
@ -275,14 +275,14 @@ assimp extract <model> [<out>] [-t<n>] [-f<fmt>] [-ba] [-s] [common parameters]
<p> <p>
<tt> <tt>
model<br></tt><br> model<br></tt><br>
Required. Relative or absolute path to the input model. Required. Relative or absolute path to the input model.
</p> </p>
<p> <p>
<tt> <tt>
out<br></tt><br> out<br></tt><br>
Optional. Relative or absolute path to write the output images to. If the file name is Optional. Relative or absolute path to write the output images to. If the file name is
omitted the output images are named <tt><model-filename></tt><br> omitted the output images are named <tt><model-filename></tt><br>
The suffix <tt>_img&lt;n&gt;</tt> is appended to the file name if the -s switch is not specified The suffix <tt>_img&lt;n&gt;</tt> is appended to the file name if the -s switch is not specified
(where <tt>&lt;n&gt;</tt> is the zero-based index of the texture in the model file).<br> (where <tt>&lt;n&gt;</tt> is the zero-based index of the texture in the model file).<br>
The output file format is determined from the given file extension. Supported The output file format is determined from the given file extension. Supported
@ -296,7 +296,7 @@ written in their native file format (e.g. jpg).
<p> <p>
<tt>-t&lt;n&gt;<br> <tt>-t&lt;n&gt;<br>
</tt><br> </tt><br>
Optional. Specifies the (zero-based) index of the embedded texture to be extracted from Optional. Specifies the (zero-based) index of the embedded texture to be extracted from
the model. If this option is *not* specified all textures found are exported. the model. If this option is *not* specified all textures found are exported.
The long form of this parameter is <tt>--texture=&lt;n&gt;</tt>. The long form of this parameter is <tt>--texture=&lt;n&gt;</tt>.
</p> </p>
@ -348,8 +348,8 @@ imported data structure and writes it to <tt>test_img0.bmp</tt>.
@code @code
assimp extract files\*.mdl *.bmp assimp extract files\*.mdl *.bmp
assimp extract files\*.mdl *.bmp assimp extract files\*.mdl *.bmp
@endcode @endcode
Extracts all embedded textures from all loadable .mdl files in the 'files' subdirectory Extracts all embedded textures from all loadable .mdl files in the 'files' subdirectory
@ -361,10 +361,10 @@ and writes them to bitmaps which are named <tt><model-file>_img<image-index>.bmp
/** /**
@page common Common parameters @page common Common parameters
The parameters described on this page are commonly used by almost every assimp command. They The parameters described on this page are commonly used by almost every assimp command. They
specify how the library will postprocess the imported data. This is done by several specify how the library will postprocess the imported data. This is done by several
configurable pipeline stages, called 'post processing steps'. Below you can find a list configurable pipeline stages, called 'post processing steps'. Below you can find a list
of all supported steps along with short descriptions of what they're doing. <br><b>Programmers</b>: of all supported steps along with short descriptions of what they're doing. <br><b>Programmers</b>:
more information can be found in the <tt>aiPostProcess.h</tt> header. more information can be found in the <tt>aiPostProcess.h</tt> header.
<table border="1"> <table border="1">
@ -376,7 +376,7 @@ more information can be found in the <tt>aiPostProcess.h</tt> header.
<tr> <tr>
<td><tt>-ptv</tt></td> <td><tt>-ptv</tt></td>
<td><tt>--pretransform-vertices</tt></td> <td><tt>--pretransform-vertices</tt></td>
<td>Move all vertices into worldspace and collapse the scene graph. Animation data is lost. <td>Move all vertices into worldspace and collapse the scene graph. Animation data is lost.
This is intended for applications which don't support scenegraph-oriented rendering.</td> This is intended for applications which don't support scenegraph-oriented rendering.</td>
</tr> </tr>
<tr> <tr>
@ -428,7 +428,7 @@ more information can be found in the <tt>aiPostProcess.h</tt> header.
<tr> <tr>
<td><tt>-icl</tt></td> <td><tt>-icl</tt></td>
<td><tt>--improve-cache-locality</tt></td> <td><tt>--improve-cache-locality</tt></td>
<td>Improve the cache locality of the vertex buffer by reordering the index buffer <td>Improve the cache locality of the vertex buffer by reordering the index buffer
to achieve a lower ACMR (average post-transform vertex cache miss ratio)</td> to achieve a lower ACMR (average post-transform vertex cache miss ratio)</td>
</tr> </tr>
<tr> <tr>
@ -515,7 +515,7 @@ For convenience some default postprocessing configurations are provided.
The corresponding command line parameter is <tt>-c&lt;name&gt;</tt> (or <tt>--config=&lt;name&gt;</tt>). The corresponding command line parameter is <tt>-c&lt;name&gt;</tt> (or <tt>--config=&lt;name&gt;</tt>).
<table border="1"> <table border="1">
<tr> <tr>
<th>Name</th> <th>Name</th>
<th>Description</th> <th>Description</th>
@ -543,7 +543,7 @@ The corresponding command line parameter is <tt>-c&lt;name&gt;</tt> (or <tt>--co
There are also some common flags to customize Assimp's logging behaviour: There are also some common flags to customize Assimp's logging behaviour:
<table border="1"> <table border="1">
<tr> <tr>
<th>Name</th> <th>Name</th>
<th>Description</th> <th>Description</th>
@ -558,7 +558,7 @@ There are also some common flags to customize Assimp's logging behaviour:
</tr> </tr>
<tr> <tr>
<td><tt>-v</tt> or <tt>--verbose</tt></td> <td><tt>-v</tt> or <tt>--verbose</tt></td>
<td>Enables verbose logging. Debug messages will be produced too. This might <td>Enables verbose logging. Debug messages will be produced too. This might
decrease loading performance and result in *very* long logs ... use with caution if you experience strange issues.</td> decrease loading performance and result in *very* long logs ... use with caution if you experience strange issues.</td>
</tr> </tr>
</table> </table>

Some files were not shown because too many files have changed in this diff Show More