removed trailing spaces and tabs from source and text
This commit ignores the “contrib” folder in order to prevent merge conflicts in dependencies, should these be updated via git.
This commit is contained in:
Krishty
parent
fc22d6cdae
commit
758116b083
|
|
@ -291,7 +291,7 @@ void Discreet3DSExporter::WriteMaterials() {
|
|||
ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_SPECULAR);
|
||||
WriteColor(color);
|
||||
}
|
||||
|
||||
|
||||
if (mat.Get(AI_MATKEY_COLOR_AMBIENT, color) == AI_SUCCESS) {
|
||||
ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_AMBIENT);
|
||||
WriteColor(color);
|
||||
|
|
|
|||
|
|
@ -274,7 +274,7 @@ private:
|
|||
if (ret) {
|
||||
value = std::atoi(strValue.c_str());
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -303,7 +303,7 @@ void AMFImporter::ParseNode_Root() {
|
|||
}
|
||||
XmlNode node = *root;
|
||||
mUnit = ai_tolower(std::string(node.attribute("unit").as_string()));
|
||||
|
||||
|
||||
mVersion = node.attribute("version").as_string();
|
||||
|
||||
// Read attributes for node <amf>.
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ void AMFImporter::ParseNode_Mesh(XmlNode &node) {
|
|||
found_volumes = true;
|
||||
}
|
||||
ParseHelper_Node_Exit();
|
||||
}
|
||||
}
|
||||
|
||||
if (!found_verts && !found_volumes) {
|
||||
mNodeElement_Cur->Child.push_back(ne);
|
||||
|
|
@ -199,9 +199,9 @@ void AMFImporter::ParseNode_Volume(XmlNode &node) {
|
|||
|
||||
// Read attributes for node <color>.
|
||||
// and assign read data
|
||||
|
||||
|
||||
((AMFVolume *)ne)->MaterialID = node.attribute("materialid").as_string();
|
||||
|
||||
|
||||
((AMFVolume *)ne)->Type = type;
|
||||
// Check for child nodes
|
||||
bool col_read = false;
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*
|
|||
}
|
||||
|
||||
tcol = Color->Color;
|
||||
|
||||
|
||||
// Check if default color must be used
|
||||
if ((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0)) {
|
||||
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.
|
||||
vertexCoordinateArray.reserve(vn->Child.size());
|
||||
vertexCoordinateArray.reserve(vn->Child.size());
|
||||
|
||||
// colors count equal vertices count.
|
||||
pVertexColorArray.resize(vn->Child.size());
|
||||
pVertexColorArray.resize(vn->Child.size());
|
||||
col_idx = 0;
|
||||
|
||||
// Inside vertices collect all data and place to arrays
|
||||
|
|
|
|||
|
|
@ -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
|
||||
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)
|
||||
std::vector<unsigned int> was_copied_to;
|
||||
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) {
|
||||
const unsigned int out_vertex_index = LIMIT;
|
||||
|
||||
aiMesh* out_mesh = new aiMesh();
|
||||
aiMesh* out_mesh = new aiMesh();
|
||||
out_mesh->mNumVertices = 0;
|
||||
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
|
||||
if (WAS_NOT_COPIED == was_copied_to[index]) {
|
||||
iNeed++;
|
||||
iNeed++;
|
||||
}
|
||||
}
|
||||
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];
|
||||
}
|
||||
}
|
||||
// vertex colors
|
||||
// vertex colors
|
||||
for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
|
||||
if (in_mesh->HasVertexColors( c)) {
|
||||
out_mesh->mColors[c][out_mesh->mNumVertices] = in_mesh->mColors[c][index];
|
||||
|
|
|
|||
|
|
@ -22,13 +22,13 @@ struct aiNode;
|
|||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** 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:
|
||||
|
||||
|
||||
void SetLimit(unsigned int l) {
|
||||
LIMIT = l;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <assimp/IOSystem.hpp>
|
||||
#include <assimp/Exporter.hpp>
|
||||
|
||||
namespace Assimp {
|
||||
namespace Assimp {
|
||||
|
||||
void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -52,9 +52,9 @@ namespace Assimp {
|
|||
namespace Blender {
|
||||
|
||||
// -------------------------------------------------------------------------------------------
|
||||
/**
|
||||
/**
|
||||
* 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 {
|
||||
|
|
@ -67,7 +67,7 @@ public:
|
|||
}
|
||||
|
||||
// --------------------
|
||||
/**
|
||||
/**
|
||||
* Check if *this* modifier is active, given a ModifierData& block.
|
||||
*/
|
||||
virtual bool IsActive( const ModifierData& /*modin*/) {
|
||||
|
|
@ -75,10 +75,10 @@ public:
|
|||
}
|
||||
|
||||
// --------------------
|
||||
/**
|
||||
/**
|
||||
* Apply the modifier to a given output node. The original data used
|
||||
* 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*/,
|
||||
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 {
|
||||
|
|
@ -113,8 +113,8 @@ private:
|
|||
// MODIFIERS /////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// -------------------------------------------------------------------------------------------
|
||||
/**
|
||||
* Mirror modifier. Status: implemented.
|
||||
/**
|
||||
* Mirror modifier. Status: implemented.
|
||||
*/
|
||||
// -------------------------------------------------------------------------------------------
|
||||
class BlenderModifier_Mirror : public BlenderModifier {
|
||||
|
|
|
|||
|
|
@ -148,12 +148,12 @@ void C4DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
|
|||
|
||||
// Generate the root-node
|
||||
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;
|
||||
|
||||
pScene->mRootNode->mTransformation.c3 = -0.01f;
|
||||
|
||||
// first convert all materials
|
||||
ReadMaterials(doc->GetFirstMaterial());
|
||||
|
||||
|
|
|
|||
|
|
@ -884,7 +884,7 @@ void COBImporter::ReadBinaryFile(Scene &out, StreamReaderLE *reader) {
|
|||
std::string type;
|
||||
type += reader->GetI1();
|
||||
type += reader->GetI1();
|
||||
type += reader->GetI1();
|
||||
type += reader->GetI1();
|
||||
type += reader->GetI1();
|
||||
|
||||
ChunkInfo nfo;
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ class COBImporter : public BaseImporter
|
|||
public:
|
||||
COBImporter();
|
||||
~COBImporter();
|
||||
|
||||
|
||||
// --------------------
|
||||
bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
|
||||
bool checkSig) const;
|
||||
|
|
|
|||
|
|
@ -1675,7 +1675,7 @@ void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/)
|
|||
const Material &material = matIt->second;
|
||||
// a material is only a reference to an effect
|
||||
ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect);
|
||||
if (effIt == pParser.mEffectLibrary.end())
|
||||
if (effIt == pParser.mEffectLibrary.end())
|
||||
continue;
|
||||
Effect &effect = effIt->second;
|
||||
|
||||
|
|
|
|||
|
|
@ -547,7 +547,7 @@ void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
|
|||
++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" );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ namespace DXF {
|
|||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/**
|
||||
/**
|
||||
* @brief DXF importer implementation.
|
||||
*/
|
||||
class DXFImporter : public BaseImporter {
|
||||
|
|
|
|||
|
|
@ -862,7 +862,7 @@ bool FBXConverter::GenerateTransformationNodeChain(const Model &model, const std
|
|||
output_nodes.push_back(std::move(nd));
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) {
|
||||
const PropertyTable &props = model.Props();
|
||||
DirectPropertyMap unparsedProperties = props.GetUnparsedProperties();
|
||||
|
|
@ -3572,7 +3572,7 @@ void FBXConverter::ConvertOrphanedEmbeddedTextures() {
|
|||
if (texture->Media() && texture->Media()->ContentLength() > 0) {
|
||||
realTexture = texture;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (...) {
|
||||
// do nothing
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ namespace Assimp {
|
|||
namespace FBX {
|
||||
|
||||
class Document;
|
||||
/**
|
||||
/**
|
||||
* Convert a FBX #Document to #aiScene
|
||||
* @param out Empty scene to be populated
|
||||
* @param doc Parsed FBX document
|
||||
|
|
@ -182,7 +182,7 @@ private:
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
void ConvertModel(const Model &model, aiNode *parent, aiNode *root_node,
|
||||
const aiMatrix4x4 &absolute_transform);
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// MeshGeometry -> aiMesh, return mesh index + 1 or 0 if the conversion failed
|
||||
std::vector<unsigned int>
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
return GetConnectionsSequenced(source, true, ConnectionsBySource(),classnames, count);
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ namespace FBX {
|
|||
}
|
||||
|
||||
class FBX::Node {
|
||||
public:
|
||||
public:
|
||||
// TODO: accessors
|
||||
std::string name; // node name
|
||||
std::vector<FBX::FBXExportProperty> properties; // node properties
|
||||
|
|
|
|||
|
|
@ -498,7 +498,7 @@ void FBXExporter::WriteDocuments ()
|
|||
if (!binary) {
|
||||
WriteAsciiSectionHeader("Documents Description");
|
||||
}
|
||||
|
||||
|
||||
// not sure what the use of multiple documents would be,
|
||||
// or whether any end-application supports it
|
||||
FBX::Node docs("Documents");
|
||||
|
|
@ -1258,7 +1258,7 @@ void FBXExporter::WriteObjects ()
|
|||
indent = 2;
|
||||
vertexcolors.End(outstream, binary, indent, true);
|
||||
}
|
||||
|
||||
|
||||
// uvs, if any
|
||||
for (size_t uvi = 0; uvi < m->GetNumUVChannels(); ++uvi) {
|
||||
if (m->mNumUVComponents[uvi] > 2) {
|
||||
|
|
@ -1751,7 +1751,7 @@ void FBXExporter::WriteObjects ()
|
|||
bsnode.AddProperty(blendshape_uid);
|
||||
bsnode.AddProperty(blendshape_name + FBX::SEPARATOR + "Blendshape");
|
||||
bsnode.AddProperty("Shape");
|
||||
bsnode.AddChild("Version", int32_t(100));
|
||||
bsnode.AddChild("Version", int32_t(100));
|
||||
bsnode.Begin(outstream, binary, indent);
|
||||
bsnode.DumpProperties(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,
|
||||
// which will be used later to mark them as type "limbNode".
|
||||
std::unordered_set<const aiNode*> limbnodes;
|
||||
|
||||
|
||||
//actual bone nodes in fbx, without parenting-up
|
||||
std::unordered_set<std::string> setAllBoneNamesInScene;
|
||||
for(unsigned int m = 0; m < mScene->mNumMeshes; ++ m)
|
||||
|
|
@ -1887,7 +1887,7 @@ void FBXExporter::WriteObjects ()
|
|||
setAllBoneNamesInScene.insert(pMesh->mBones[b]->mName.data);
|
||||
}
|
||||
aiMatrix4x4 mxTransIdentity;
|
||||
|
||||
|
||||
// and a map of nodes by bone name, as finding them is annoying.
|
||||
std::map<std::string,aiNode*> node_by_bone;
|
||||
for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) {
|
||||
|
|
@ -1956,7 +1956,7 @@ void FBXExporter::WriteObjects ()
|
|||
}
|
||||
if (end) { break; }
|
||||
}
|
||||
|
||||
|
||||
// if it was the skeleton root we can finish here
|
||||
if (end) { break; }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -142,8 +142,8 @@ Material::~Material() {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
|
||||
Object(id,element,name),
|
||||
uvScaling(1.0f,1.0f),
|
||||
Object(id,element,name),
|
||||
uvScaling(1.0f,1.0f),
|
||||
media(0) {
|
||||
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) :
|
||||
Object(id,element,name),
|
||||
contentLength(0),
|
||||
Object(id,element,name),
|
||||
contentLength(0),
|
||||
content(0) {
|
||||
const Scope& sc = GetRequiredScope(element);
|
||||
|
||||
|
|
|
|||
|
|
@ -633,7 +633,7 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
|
|||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// materials are handled separately. First of all, they are assigned per-face
|
||||
// and not per polyvert. Secondly, ReferenceInformationType=IndexToDirect
|
||||
// has a slightly different meaning for materials.
|
||||
|
|
|
|||
|
|
@ -52,8 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
namespace Assimp {
|
||||
namespace FBX {
|
||||
|
||||
/**
|
||||
* DOM base class for all kinds of FBX geometry
|
||||
/**
|
||||
* DOM base class for all kinds of FBX geometry
|
||||
*/
|
||||
class Geometry : public Object
|
||||
{
|
||||
|
|
@ -76,7 +76,7 @@ private:
|
|||
typedef std::vector<int> MatIndexArray;
|
||||
|
||||
|
||||
/**
|
||||
/**
|
||||
* DOM class for FBX geometry of type "Mesh"
|
||||
*/
|
||||
class MeshGeometry : public Geometry
|
||||
|
|
@ -84,7 +84,7 @@ class MeshGeometry : public Geometry
|
|||
public:
|
||||
/** The class constructor */
|
||||
MeshGeometry( uint64_t id, const Element& element, const std::string& name, const Document& doc );
|
||||
|
||||
|
||||
/** The class destructor */
|
||||
virtual ~MeshGeometry();
|
||||
|
||||
|
|
|
|||
|
|
@ -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 Element*> LazyPropertyMap;
|
||||
|
||||
/**
|
||||
/**
|
||||
* Represents a property table as can be found in the newer FBX files (Properties60, Properties70)
|
||||
*/
|
||||
class PropertyTable {
|
||||
|
|
@ -130,7 +130,7 @@ private:
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
inline
|
||||
inline
|
||||
T PropertyGet(const PropertyTable& in, const std::string& name, const T& defaultValue) {
|
||||
const Property* const prop = in.Get(name);
|
||||
if( nullptr == prop) {
|
||||
|
|
@ -148,7 +148,7 @@ T PropertyGet(const PropertyTable& in, const std::string& name, const T& default
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
inline
|
||||
inline
|
||||
T PropertyGet(const PropertyTable& in, const std::string& name, bool& result, bool useTemplate=false ) {
|
||||
const Property* prop = in.Get(name);
|
||||
if( nullptr == prop) {
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ std::string GetLineAndColumnText(unsigned int line, unsigned int column)
|
|||
std::string GetTokenText(const Token* tok)
|
||||
{
|
||||
if(tok->IsBinary()) {
|
||||
return static_cast<std::string>( Formatter::format() <<
|
||||
return static_cast<std::string>( Formatter::format() <<
|
||||
" (" << TokenTypeString(tok->Type()) <<
|
||||
", offset 0x" << std::hex << tok->Offset() << ") " );
|
||||
}
|
||||
|
|
|
|||
|
|
@ -153,10 +153,10 @@ void HMPImporter::InternReadFile(const std::string &pFile,
|
|||
} else {
|
||||
// Print the magic word to the logger
|
||||
std::string szBuffer = ai_str_toprintable((const char *)&iMagic, sizeof(iMagic));
|
||||
|
||||
|
||||
delete[] mBuffer;
|
||||
mBuffer = nullptr;
|
||||
|
||||
|
||||
// We're definitely unable to load this file
|
||||
throw DeadlyImportError("Unknown HMP subformat ", pFile,
|
||||
". Magic word (", szBuffer, ") is not known");
|
||||
|
|
|
|||
|
|
@ -514,7 +514,7 @@ IfcFloat Curve::GetParametricRangeDelta() 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( b ) );
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
if(curmesh.mVertcnt.size() > 0) {
|
||||
IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front());
|
||||
|
||||
|
||||
std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
|
||||
|
||||
|
||||
for(size_t a = 0; a < it->contour.size(); ++a)
|
||||
worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0);
|
||||
|
||||
|
||||
IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
|
||||
|
||||
|
||||
reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ Open Asset Import Library (ASSIMP)
|
|||
Copyright (c) 2006-2020, ASSIMP Development Team
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
|
|
@ -23,16 +23,16 @@ following conditions are met:
|
|||
derived from this software without specific prior
|
||||
written permission of the ASSIMP Development Team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
----------------------------------------------------------------------
|
||||
|
|
@ -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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'OwnerHistory' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Name' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Description' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RepresentationIdentifier' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RepresentationType' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Items' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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++];
|
||||
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;
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1290,20 +1290,20 @@ template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIS
|
|||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Description' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Representations' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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++];
|
||||
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;
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Representation' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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++];
|
||||
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;
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SelfIntersect' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1400,27 +1400,27 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db,
|
|||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Axis2' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'LocalOrigin' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Scale' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1433,7 +1433,7 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& d
|
|||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Description' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'FirstOperand' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SecondOperand' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RelatedBuildingElement' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1681,12 +1681,12 @@ template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db,
|
|||
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
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RelatingStructure' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ProfileName' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RefDirection' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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++];
|
||||
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;
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SameSense' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ParentCurve' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'YDim' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RelativePlacement' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Position' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Angle' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Radius' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'InnerRadius' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'StartParam' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'EndParam' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'AgreementFlag' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'PolygonalBoundary' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Phase' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RepresentationContexts' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'UnitsInContext' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Trim1' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Trim2' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SenseAgreement' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'MasterRepresentation' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RelatedObjects' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'MappingTarget' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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++];
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'UnitType' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -2719,13 +2719,13 @@ template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const L
|
|||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'CompositionType' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ElevationOfTerrain' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'BuildingAddress' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'OverallDepth' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'WebThickness' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'FlangeThickness' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'FilletRadius' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Unit' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'OverallWidth' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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++];
|
||||
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;
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Styles' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Name' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Dir' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Unit' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ Open Asset Import Library (ASSIMP)
|
|||
Copyright (c) 2006-2020, ASSIMP Development Team
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
|
|
@ -23,16 +23,16 @@ following conditions are met:
|
|||
derived from this software without specific prior
|
||||
written permission of the ASSIMP Development Team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
----------------------------------------------------------------------
|
||||
|
|
@ -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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Styles' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -173,7 +173,7 @@ template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST&
|
|||
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 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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Magnitude' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Green' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Blue' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RefLongitude' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RefElevation' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'LandTitleNumber' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SiteAddress' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ControlPointsList' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'CurveForm' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ClosedCurve' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SelfIntersect' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Depth' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'RelatedOpeningElement' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Scale3' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -716,14 +716,14 @@ template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIS
|
|||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ContextType' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Precision' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'WorldCoordinateSystem' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'TrueNorth' argument
|
||||
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 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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Name' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -858,12 +858,12 @@ template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& p
|
|||
size_t base = 0;
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'MappedRepresentation' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1012,12 +1012,12 @@ template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& par
|
|||
size_t base = 0;
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'UnitComponent' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Orientation' argument
|
||||
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; }
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'HasProperties' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1274,7 +1274,7 @@ template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& para
|
|||
size_t base = 0;
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'Quantities' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1379,7 +1379,7 @@ template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, con
|
|||
size_t base = 0;
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ElevationWithFlooring' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
@ -1484,7 +1484,7 @@ template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const
|
|||
size_t base = 0;
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'XDim' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'YDim' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ZDim' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ConversionFactor' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SemiAxis2' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
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));
|
||||
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++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
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
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'DiffuseColour' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'TransmissionColour' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'DiffuseTransmissionColour' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ReflectionColour' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SpecularColour' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'SpecularHighlight' argument
|
||||
std::shared_ptr<const DataType> arg = params[base++];
|
||||
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`")); }
|
||||
} while(0);
|
||||
do { // convert the 'ReflectanceMethod' argument
|
||||
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`")); }
|
||||
} while(0);
|
||||
return base;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -5,8 +5,8 @@ Open Asset Import Library (ASSIMP)
|
|||
Copyright (c) 2006-2020, ASSIMP Development Team
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
|
|
@ -23,16 +23,16 @@ following conditions are met:
|
|||
derived from this software without specific prior
|
||||
written permission of the ASSIMP Development Team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
----------------------------------------------------------------------
|
||||
|
|
@ -51,12 +51,12 @@ namespace Schema_4 {
|
|||
|
||||
using namespace STEP;
|
||||
using namespace STEP::EXPRESS;
|
||||
|
||||
|
||||
|
||||
|
||||
struct NotImplemented : public ObjectHelper<NotImplemented,0> {
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
// ******************************************************************************
|
||||
// IFC Custom data types
|
||||
|
|
|
|||
|
|
@ -273,7 +273,7 @@ private:
|
|||
std::vector<aiNodeAnim*>& anims);
|
||||
|
||||
private:
|
||||
/// Configuration option: desired output FPS
|
||||
/// Configuration option: desired output FPS
|
||||
double fps;
|
||||
|
||||
/// Configuration option: speed flag was set?
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ enum PrePostBehaviour
|
|||
/** \brief Data structure for a LWO animation keyframe
|
||||
*/
|
||||
struct Key {
|
||||
Key() AI_NO_EXCEPT
|
||||
Key() AI_NO_EXCEPT
|
||||
: time()
|
||||
, value()
|
||||
, inter(IT_LINE)
|
||||
|
|
|
|||
|
|
@ -200,7 +200,7 @@ void LWSImporter::ReadEnvelope(const LWS::Element &dad, LWO::Envelope &fill) {
|
|||
|
||||
// reserve enough storage
|
||||
std::list<LWS::Element>::const_iterator it = dad.children.begin();
|
||||
|
||||
|
||||
fill.keys.reserve(strtoul10(it->tokens[1].c_str()));
|
||||
|
||||
for (++it; it != dad.children.end(); ++it) {
|
||||
|
|
@ -466,7 +466,7 @@ std::string LWSImporter::FindLWOFile(const std::string &in) {
|
|||
std::string tmp(in);
|
||||
if (in.length() > 3 && in[1] == ':' && in[2] != '\\' && in[2] != '/') {
|
||||
tmp = in[0] + (std::string(":\\") + in.substr(2));
|
||||
}
|
||||
}
|
||||
|
||||
if (io->Exists(tmp)) {
|
||||
return in;
|
||||
|
|
|
|||
|
|
@ -84,11 +84,11 @@ public:
|
|||
void reset();
|
||||
|
||||
// The Name access, empty string returned when no m3d instance.
|
||||
std::string Name() const;
|
||||
std::string Name() const;
|
||||
|
||||
/// Executes a save.
|
||||
unsigned char *Save(int quality, int flags, unsigned int &size);
|
||||
|
||||
|
||||
/// Clearer
|
||||
void ClearSave();
|
||||
|
||||
|
|
@ -113,16 +113,16 @@ inline std::string M3DWrapper::Name() const {
|
|||
return std::string();
|
||||
}
|
||||
|
||||
inline M3DWrapper::operator bool() const {
|
||||
return m3d_ != nullptr;
|
||||
inline M3DWrapper::operator bool() const {
|
||||
return m3d_ != nullptr;
|
||||
}
|
||||
|
||||
inline m3d_t *M3DWrapper::operator->() const {
|
||||
return m3d_;
|
||||
return m3d_;
|
||||
}
|
||||
|
||||
inline m3d_t *M3DWrapper::M3D() const {
|
||||
return m3d_;
|
||||
return m3d_;
|
||||
}
|
||||
|
||||
} // namespace Assimp
|
||||
|
|
|
|||
|
|
@ -829,7 +829,7 @@ unsigned char *_m3dstbi_zlib_compress(unsigned char *data, int data_len, int *ou
|
|||
#include <sys/time.h>
|
||||
#endif
|
||||
|
||||
#if !defined(M3D_NOIMPORTER)
|
||||
#if !defined(M3D_NOIMPORTER)
|
||||
/* helper functions for the ASCII parser */
|
||||
static char *_m3d_findarg(char *s) {
|
||||
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) {
|
||||
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;
|
||||
}
|
||||
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));
|
||||
memcpy( length, &v, sizeof(uint32_t));
|
||||
memcpy( length, &v, sizeof(uint32_t));
|
||||
len += v;
|
||||
out = NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -485,7 +485,7 @@ void MD5Importer::LoadMD5MeshFile() {
|
|||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -120,13 +120,13 @@ struct Surface {
|
|||
, ulFlags()
|
||||
, ulNumCompFrames()
|
||||
, ulNumBaseFrames()
|
||||
, ulNumShaders()
|
||||
, ulNumShaders()
|
||||
, ulNumVertices()
|
||||
, ulNumTriangles()
|
||||
, ulOffsetTriangles()
|
||||
, ulOffsetShaders()
|
||||
, ulOffsetTexCoords()
|
||||
, ulOffsetBaseVerts()
|
||||
, ulOffsetBaseVerts()
|
||||
, ulOffsetCompVerts()
|
||||
, ulOffsetFrameBaseFrames()
|
||||
, ulOffsetFrameCompFrames()
|
||||
|
|
|
|||
|
|
@ -629,7 +629,7 @@ void HL1MDLLoader::read_meshes() {
|
|||
+-- bodypart --+-- model -- [mesh index, mesh index, ...]
|
||||
| |
|
||||
| +-- model -- [mesh index, mesh index, ...]
|
||||
| |
|
||||
| |
|
||||
| ...
|
||||
|
|
||||
|-- bodypart -- ...
|
||||
|
|
@ -1298,7 +1298,7 @@ void HL1MDLLoader::read_global_info() {
|
|||
* @note The structure of this method is taken from HL2 source code.
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* source:
|
||||
* HL1 source code.
|
||||
* file: studio_render.cpp
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ namespace pmx
|
|||
const unsigned int targetSize = size * 3; // enough to encode
|
||||
char *targetStart = new char[targetSize];
|
||||
std::memset(targetStart, 0, targetSize * sizeof(char));
|
||||
|
||||
|
||||
utf8::utf16to8( sourceStart, sourceStart + size/2, targetStart );
|
||||
|
||||
std::string result(targetStart);
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
|
|||
const char* car = buffer;
|
||||
const char* end = buffer + mBuffer2.size();
|
||||
NextToken(&car, end);
|
||||
|
||||
|
||||
if (car < end - 2 && car[0] == 'S' && car[1] == 'T') {
|
||||
hasTexCoord = true; car += 2;
|
||||
}
|
||||
|
|
@ -164,7 +164,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
|
|||
dimensions = 3;
|
||||
hasHomogenous = false;
|
||||
NextToken(&car, end);
|
||||
|
||||
|
||||
// at this point the next token should be an integer number
|
||||
if (car >= end - 1 || *car < '0' || *car > '9') {
|
||||
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");
|
||||
break;
|
||||
}
|
||||
aiVector3D& v = mesh->mVertices[i];
|
||||
aiVector3D& v = mesh->mVertices[i];
|
||||
sz = line;
|
||||
|
||||
// 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);
|
||||
fast_atoreal_move<ai_real>(sz,(ai_real&)n.z);
|
||||
}
|
||||
|
||||
|
||||
// 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,
|
||||
// until the next comment or end of line
|
||||
|
|
@ -321,7 +321,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
|
|||
++i;
|
||||
++faces;
|
||||
}
|
||||
|
||||
|
||||
// generate the output node graph
|
||||
pScene->mRootNode = new aiNode();
|
||||
pScene->mRootNode->mName.Set("<OFFRoot>");
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ public:
|
|||
~ObjExporter();
|
||||
std::string GetMaterialLibName();
|
||||
std::string GetMaterialLibFileName();
|
||||
|
||||
|
||||
/// public string-streams to write all output into
|
||||
std::ostringstream mOutput, mOutputMat;
|
||||
|
||||
|
|
@ -137,13 +137,13 @@ private:
|
|||
}
|
||||
};
|
||||
|
||||
struct aiVectorCompare {
|
||||
bool operator() (const aiVector3D& a, const aiVector3D& b) const {
|
||||
if(a.x < b.x) return true;
|
||||
if(a.x > b.x) return false;
|
||||
if(a.y < b.y) return true;
|
||||
if(a.y > b.y) return false;
|
||||
if(a.z < b.z) return true;
|
||||
struct aiVectorCompare {
|
||||
bool operator() (const aiVector3D& a, const aiVector3D& b) const {
|
||||
if(a.x < b.x) return true;
|
||||
if(a.x > b.x) return false;
|
||||
if(a.y < b.y) return true;
|
||||
if(a.y > b.y) return false;
|
||||
if(a.z < b.z) return true;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
|
@ -153,7 +153,7 @@ private:
|
|||
int mNextIndex;
|
||||
typedef std::map<T, int, Compare> dataType;
|
||||
dataType vecMap;
|
||||
|
||||
|
||||
public:
|
||||
indexMap()
|
||||
: mNextIndex(1) {
|
||||
|
|
|
|||
|
|
@ -146,7 +146,7 @@ void ObjFileMtlImporter::load() {
|
|||
++m_DataIt;
|
||||
ai_real 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);
|
||||
} break;
|
||||
|
|
|
|||
|
|
@ -438,7 +438,7 @@ void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) {
|
|||
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;
|
||||
} else {
|
||||
bone.mOffsetMatrix = asBones[bone.iParent].mOffsetMatrix * pc->mTransformation;
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
|
|||
if (exporter.mOutput.fail()) {
|
||||
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.
|
||||
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
|
||||
if (outfile == nullptr) {
|
||||
|
|
@ -88,7 +88,7 @@ void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene*
|
|||
if (exporter.mOutput.fail()) {
|
||||
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.
|
||||
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wb"));
|
||||
if (outfile == nullptr) {
|
||||
|
|
@ -139,9 +139,9 @@ STLExporter::STLExporter(const char* _filename, const aiScene* pScene, bool expo
|
|||
if (exportPointClouds) {
|
||||
WritePointCloud("Assimp_Pointcloud", pScene );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Export the assimp mesh
|
||||
// Export the assimp mesh
|
||||
const std::string name = "AssimpScene";
|
||||
mOutput << SolidToken << " " << name << endl;
|
||||
for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
|
||||
|
|
|
|||
|
|
@ -372,7 +372,7 @@ void STLImporter::LoadASCIIFile(aiNode *root) {
|
|||
pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
|
||||
for (size_t i=0; i<pMesh->mNumVertices; ++i ) {
|
||||
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;
|
||||
}
|
||||
positionBuffer.clear();
|
||||
|
|
@ -382,7 +382,7 @@ void STLImporter::LoadASCIIFile(aiNode *root) {
|
|||
pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
|
||||
for (size_t i=0; i<pMesh->mNumVertices; ++i ) {
|
||||
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;
|
||||
}
|
||||
normalBuffer.clear();
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ void ExportSceneXFile(const char* pFile,IOSystem* pIOSystem, const aiScene* pSce
|
|||
if (iDoTheExportThing.mOutput.fail()) {
|
||||
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
|
||||
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
|
||||
if (outfile == nullptr) {
|
||||
|
|
|
|||
|
|
@ -94,9 +94,9 @@ protected:
|
|||
void PushTag() { startstr.append( " "); }
|
||||
|
||||
/// Leaves an element, decreasing the indentation
|
||||
void PopTag() {
|
||||
ai_assert( startstr.length() > 1);
|
||||
startstr.erase( startstr.length() - 2);
|
||||
void PopTag() {
|
||||
ai_assert( startstr.length() > 1);
|
||||
startstr.erase( startstr.length() - 2);
|
||||
}
|
||||
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -180,6 +180,6 @@ const aiImporterDesc *X3DImporter::GetInfo() const {
|
|||
return &Description;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
|
||||
|
|
|
|||
|
|
@ -240,7 +240,7 @@ void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
|
|||
void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) {
|
||||
for (XmlNode ¤tNode : node.children()) {
|
||||
const std::string &s = ai_stdStrToLower(currentNode.name());
|
||||
|
||||
|
||||
// XXX right now we'd skip <lighting> if it comes after
|
||||
// <object> or <mesh>
|
||||
if (s == "lighting") {
|
||||
|
|
|
|||
|
|
@ -388,9 +388,9 @@ struct CustomExtension {
|
|||
}
|
||||
|
||||
CustomExtension() = default;
|
||||
|
||||
|
||||
~CustomExtension() = default;
|
||||
|
||||
|
||||
CustomExtension(const CustomExtension &other) :
|
||||
name(other.name),
|
||||
mStringValue(other.mStringValue),
|
||||
|
|
|
|||
|
|
@ -410,14 +410,14 @@ inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Prim
|
|||
|
||||
// Not same size, convert
|
||||
switch (componentBytes) {
|
||||
case sizeof(uint32_t):
|
||||
CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh);
|
||||
case sizeof(uint32_t):
|
||||
CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh);
|
||||
break;
|
||||
case sizeof(uint16_t):
|
||||
CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh);
|
||||
case sizeof(uint16_t):
|
||||
CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh);
|
||||
break;
|
||||
case sizeof(uint8_t):
|
||||
CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh);
|
||||
case sizeof(uint8_t):
|
||||
CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh);
|
||||
break;
|
||||
default:
|
||||
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);
|
||||
|
||||
switch (accessor.componentType) {
|
||||
case ComponentType_BYTE:
|
||||
GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
case ComponentType_BYTE:
|
||||
GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
break;
|
||||
case ComponentType_UNSIGNED_BYTE:
|
||||
GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
break;
|
||||
case ComponentType_SHORT:
|
||||
GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
break;
|
||||
case ComponentType_UNSIGNED_SHORT:
|
||||
GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
case ComponentType_UNSIGNED_SHORT:
|
||||
GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
break;
|
||||
case ComponentType_UNSIGNED_INT:
|
||||
GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
case ComponentType_UNSIGNED_INT:
|
||||
GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
break;
|
||||
case ComponentType_FLOAT:
|
||||
GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
case ComponentType_FLOAT:
|
||||
GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
|
||||
break;
|
||||
default:
|
||||
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) {
|
||||
const size_t offset = this->byteLength;
|
||||
|
||||
|
||||
// Force alignment to 4 bits
|
||||
const size_t paddedLength = (length + 3) & ~3;
|
||||
Grow(paddedLength);
|
||||
|
|
|
|||
|
|
@ -452,7 +452,7 @@ namespace glTF2 {
|
|||
WriteTex(materialClearcoat, clearcoat.clearcoatTexture, "clearcoatTexture", w.mAl);
|
||||
WriteTex(materialClearcoat, clearcoat.clearcoatRoughnessTexture, "clearcoatRoughnessTexture", w.mAl);
|
||||
WriteTex(materialClearcoat, clearcoat.clearcoatNormalTexture, "clearcoatNormalTexture", w.mAl);
|
||||
|
||||
|
||||
if (!materialClearcoat.ObjectEmpty()) {
|
||||
exts.AddMember("KHR_materials_clearcoat", materialClearcoat, w.mAl);
|
||||
}
|
||||
|
|
@ -468,7 +468,7 @@ namespace glTF2 {
|
|||
}
|
||||
|
||||
WriteTex(materialTransmission, transmission.transmissionTexture, "transmissionTexture", w.mAl);
|
||||
|
||||
|
||||
if (!materialTransmission.ObjectEmpty()) {
|
||||
exts.AddMember("KHR_materials_transmission", materialTransmission, w.mAl);
|
||||
}
|
||||
|
|
@ -613,7 +613,7 @@ namespace glTF2 {
|
|||
if (n.skin) {
|
||||
obj.AddMember("skin", n.skin->index, w.mAl);
|
||||
}
|
||||
|
||||
|
||||
//gltf2 spec does not support "skeletons" under node
|
||||
if(n.skeletons.size()) {
|
||||
AddRefsVector(obj, "skeletons", n.skeletons, w.mAl);
|
||||
|
|
@ -711,7 +711,7 @@ namespace glTF2 {
|
|||
if (mAsset.scene) {
|
||||
mDoc.AddMember("scene", mAsset.scene->index, mAl);
|
||||
}
|
||||
|
||||
|
||||
if(mAsset.extras) {
|
||||
mDoc.AddMember("extras", *mAsset.extras, mAl);
|
||||
}
|
||||
|
|
@ -812,7 +812,7 @@ namespace glTF2 {
|
|||
uint32_t binaryChunkLength = 0;
|
||||
if (bodyBuffer->byteLength > 0) {
|
||||
binaryChunkLength = (bodyBuffer->byteLength + 3) & ~3; // Round up to next multiple of 4
|
||||
|
||||
|
||||
auto curPaddingLength = binaryChunkLength - bodyBuffer->byteLength;
|
||||
++GLB_Chunk_count;
|
||||
|
||||
|
|
@ -881,7 +881,7 @@ namespace glTF2 {
|
|||
if (this->mAsset.extensionsUsed.KHR_materials_sheen) {
|
||||
exts.PushBack(StringRef("KHR_materials_sheen"), mAl);
|
||||
}
|
||||
|
||||
|
||||
if (this->mAsset.extensionsUsed.KHR_materials_clearcoat) {
|
||||
exts.PushBack(StringRef("KHR_materials_clearcoat"), mAl);
|
||||
}
|
||||
|
|
@ -893,7 +893,7 @@ namespace glTF2 {
|
|||
if (this->mAsset.extensionsUsed.FB_ngon_encoding) {
|
||||
exts.PushBack(StringRef("FB_ngon_encoding"), mAl);
|
||||
}
|
||||
|
||||
|
||||
if (this->mAsset.extensionsUsed.KHR_texture_basisu) {
|
||||
exts.PushBack(StringRef("KHR_texture_basisu"), mAl);
|
||||
}
|
||||
|
|
@ -901,7 +901,7 @@ namespace glTF2 {
|
|||
|
||||
if (!exts.Empty())
|
||||
mDoc.AddMember("extensionsUsed", exts, mAl);
|
||||
|
||||
|
||||
//basisu extensionRequired
|
||||
Value extsReq;
|
||||
extsReq.SetArray();
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ inline int select_fseek(FILE *file, int64_t offset, int origin) {
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
|
||||
template <>
|
||||
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)
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
// ----------------------------------------------------------------------------------
|
||||
|
|
@ -95,7 +95,7 @@ size_t DefaultIOStream::Read(void *pvBuffer,
|
|||
}
|
||||
ai_assert(nullptr != pvBuffer);
|
||||
ai_assert(0 != pSize);
|
||||
|
||||
|
||||
return (mFile ? ::fread(pvBuffer, pSize, pCount, mFile) : 0);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ static std::wstring Utf8ToWide(const char *in) {
|
|||
// size includes terminating null; std::wstring adds null automatically
|
||||
std::wstring out(static_cast<size_t>(size) - 1, L'\0');
|
||||
MultiByteToWideChar(CP_UTF8, 0, in, -1, &out[0], size);
|
||||
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ static std::string WideToUtf8(const wchar_t *in) {
|
|||
// size includes terminating null; std::string adds null automatically
|
||||
std::string out(static_cast<size_t>(size) - 1, '\0');
|
||||
WideCharToMultiByte(CP_UTF8, 0, in, -1, &out[0], size, nullptr, nullptr);
|
||||
|
||||
|
||||
return out;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -121,7 +121,7 @@ IOStream *DefaultIOSystem::Open(const char *strFile, const char *strMode) {
|
|||
if (name.empty()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
file = ::_wfopen(name.c_str(), Utf8ToWide(strMode).c_str());
|
||||
#else
|
||||
file = ::fopen(strFile, strMode);
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ namespace Assimp {
|
|||
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
|
||||
#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
|
||||
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;
|
||||
pimpl->blob = nullptr;
|
||||
}
|
||||
|
||||
|
||||
auto baseName = pProperties ? pProperties->GetPropertyString(AI_CONFIG_EXPORT_BLOB_NAME, AI_BLOBIO_MAGIC) : AI_BLOBIO_MAGIC;
|
||||
|
||||
std::shared_ptr<IOSystem> old = pimpl->mIOSystem;
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ public:
|
|||
/** Tests for the existence of a file at the given path. */
|
||||
bool Exists( const char* pFile) const {
|
||||
ai_assert( nullptr != mWrapped );
|
||||
|
||||
|
||||
std::string tmp = pFile;
|
||||
|
||||
// Currently this IOSystem is also used to open THE ONE FILE.
|
||||
|
|
@ -126,7 +126,7 @@ public:
|
|||
if ( nullptr == pFile || nullptr == pMode ) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
ai_assert( nullptr != pFile );
|
||||
ai_assert( nullptr != pMode );
|
||||
|
||||
|
|
|
|||
|
|
@ -201,7 +201,7 @@ Importer::~Importer() {
|
|||
// Register a custom post-processing step
|
||||
aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
|
||||
ai_assert( nullptr != pImp );
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
|
||||
pimpl->mPostProcessingSteps.push_back(pImp);
|
||||
|
|
@ -215,7 +215,7 @@ aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
|
|||
// Register a custom loader plugin
|
||||
aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
|
||||
ai_assert(nullptr != pImp);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
|
||||
// --------------------------------------------------------------------
|
||||
|
|
@ -242,7 +242,7 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
|
|||
pimpl->mImporter.push_back(pImp);
|
||||
ASSIMP_LOG_INFO("Registering custom importer for these file extensions: ", baked);
|
||||
ASSIMP_END_EXCEPTION_REGION(aiReturn);
|
||||
|
||||
|
||||
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.
|
||||
void Importer::SetIOHandler( IOSystem* pIOHandler) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
// If the new handler is zero, allocate a default IO implementation.
|
||||
if (!pIOHandler) {
|
||||
|
|
@ -315,7 +315,7 @@ void Importer::SetIOHandler( IOSystem* pIOHandler) {
|
|||
// Get the currently set IO handler
|
||||
IOSystem* Importer::GetIOHandler() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return pimpl->mIOHandler;
|
||||
}
|
||||
|
||||
|
|
@ -323,7 +323,7 @@ IOSystem* Importer::GetIOHandler() const {
|
|||
// Check whether a custom IO handler is currently set
|
||||
bool Importer::IsDefaultIOHandler() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return pimpl->mIsDefaultHandler;
|
||||
}
|
||||
|
||||
|
|
@ -331,9 +331,9 @@ bool Importer::IsDefaultIOHandler() const {
|
|||
// Supplies a custom progress handler to get regular callbacks during importing
|
||||
void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
|
||||
|
||||
// If the new handler is zero, allocate a default implementation.
|
||||
if (!pHandler) {
|
||||
// Release pointer in the possession of the caller
|
||||
|
|
@ -351,7 +351,7 @@ void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
|
|||
// Get the currently set progress handler
|
||||
ProgressHandler* Importer::GetProgressHandler() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return pimpl->mProgressHandler;
|
||||
}
|
||||
|
||||
|
|
@ -359,7 +359,7 @@ ProgressHandler* Importer::GetProgressHandler() const {
|
|||
// Check whether a custom progress handler is currently set
|
||||
bool Importer::IsDefaultProgressHandler() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return pimpl->mIsDefaultProgressHandler;
|
||||
}
|
||||
|
||||
|
|
@ -381,7 +381,7 @@ bool _ValidateFlags(unsigned int pFlags) {
|
|||
// Free the current scene
|
||||
void Importer::FreeScene( ) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
|
||||
delete pimpl->mScene;
|
||||
|
|
@ -396,14 +396,14 @@ void Importer::FreeScene( ) {
|
|||
// Get the current error string, if any
|
||||
const char* Importer::GetErrorString() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
// Must remain valid as long as ReadFile() or FreeFile() are not called
|
||||
return pimpl->mErrorString.c_str();
|
||||
}
|
||||
|
||||
const std::exception_ptr& Importer::GetException() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
// Must remain valid as long as ReadFile() or FreeFile() are not called
|
||||
return pimpl->mException;
|
||||
}
|
||||
|
|
@ -412,7 +412,7 @@ const std::exception_ptr& Importer::GetException() const {
|
|||
// Enable extra-verbose mode
|
||||
void Importer::SetExtraVerbose(bool bDo) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
pimpl->bExtraVerbose = bDo;
|
||||
}
|
||||
|
||||
|
|
@ -420,7 +420,7 @@ void Importer::SetExtraVerbose(bool bDo) {
|
|||
// Get the current scene
|
||||
const aiScene* Importer::GetScene() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return pimpl->mScene;
|
||||
}
|
||||
|
||||
|
|
@ -428,7 +428,7 @@ const aiScene* Importer::GetScene() const {
|
|||
// Orphan the current scene and return it.
|
||||
aiScene* Importer::GetOrphanedScene() {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
aiScene* s = pimpl->mScene;
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
|
|
@ -437,7 +437,7 @@ aiScene* Importer::GetOrphanedScene() {
|
|||
pimpl->mErrorString = std::string();
|
||||
pimpl->mException = std::exception_ptr();
|
||||
ASSIMP_END_EXCEPTION_REGION(aiScene*);
|
||||
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
|
@ -487,7 +487,7 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
|
|||
unsigned int pFlags,
|
||||
const char* pHint /*= ""*/) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
if (!pHint) {
|
||||
pHint = "";
|
||||
|
|
@ -518,7 +518,7 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void WriteLogOpening(const std::string& file) {
|
||||
|
||||
|
||||
ASSIMP_LOG_INFO("Load ", file);
|
||||
|
||||
// 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.
|
||||
const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
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
|
||||
ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException);
|
||||
|
||||
|
||||
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
|
||||
const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
// Return immediately if no scene is active
|
||||
if (!pimpl->mScene) {
|
||||
|
|
@ -832,7 +832,7 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
|
|||
}
|
||||
#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()) );
|
||||
|
||||
// update private scene flags
|
||||
|
|
@ -845,14 +845,14 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
|
|||
ASSIMP_LOG_INFO("Leaving post processing pipeline");
|
||||
|
||||
ASSIMP_END_EXCEPTION_REGION(const aiScene*);
|
||||
|
||||
|
||||
return pimpl->mScene;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
|
||||
// Return immediately if no scene is active
|
||||
|
|
@ -934,14 +934,14 @@ bool Importer::IsExtensionSupported(const char* szExtension) const {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
size_t Importer::GetImporterCount() const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return pimpl->mImporter.size();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
if (index >= pimpl->mImporter.size()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -952,7 +952,7 @@ const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
BaseImporter* Importer::GetImporter (size_t index) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
if (index >= pimpl->mImporter.size()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -963,7 +963,7 @@ BaseImporter* Importer::GetImporter (size_t index) const {
|
|||
// Find a loader plugin for a given file extension
|
||||
BaseImporter* Importer::GetImporter (const char* szExtension) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
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
|
||||
void Importer::GetExtensionList(aiString& szOut) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
std::set<std::string> str;
|
||||
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
|
||||
bool Importer::SetPropertyInteger(const char* szName, int iValue) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
bool existing;
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
|
||||
|
|
@ -1040,7 +1040,7 @@ bool Importer::SetPropertyInteger(const char* szName, int iValue) {
|
|||
// Set a configuration property
|
||||
bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
bool existing;
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
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
|
||||
bool Importer::SetPropertyString(const char* szName, const std::string& value) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
bool existing;
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
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
|
||||
bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
bool existing;
|
||||
ASSIMP_BEGIN_EXCEPTION_REGION();
|
||||
existing = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
|
||||
|
|
@ -1076,7 +1076,7 @@ bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
|
|||
// Get a configuration property
|
||||
int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn);
|
||||
}
|
||||
|
||||
|
|
@ -1084,7 +1084,7 @@ int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffff
|
|||
// Get a configuration property
|
||||
ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
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
|
||||
std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
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
|
||||
aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Get the memory requirements of a single node
|
||||
inline
|
||||
inline
|
||||
void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
|
||||
if ( nullptr == pcNode ) {
|
||||
return;
|
||||
|
|
@ -1124,7 +1124,7 @@ void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
|
|||
// Get the memory requirements of the scene
|
||||
void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
|
||||
ai_assert(nullptr != pimpl);
|
||||
|
||||
|
||||
in = aiMemoryInfo();
|
||||
aiScene* mScene = pimpl->mScene;
|
||||
|
||||
|
|
|
|||
|
|
@ -183,7 +183,7 @@ public:
|
|||
|
||||
// -------------------------------------------------------------------
|
||||
/** 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 );
|
||||
|
||||
|
|
@ -197,13 +197,13 @@ public:
|
|||
* @param enable True for validation.
|
||||
*/
|
||||
void setValidation( bool enabled );
|
||||
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Returns the current validation step.
|
||||
* @return The current validation step.
|
||||
*/
|
||||
bool getValidation() const;
|
||||
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Add a new file to the list of files to be loaded.
|
||||
* @param file File to be loaded
|
||||
|
|
|
|||
|
|
@ -205,8 +205,8 @@ corresponding preprocessor flag to selectively disable formats.
|
|||
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
|
||||
// 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.
|
||||
|
|
|
|||
|
|
@ -71,19 +71,19 @@ public:
|
|||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
inline
|
||||
Win32DebugLogStream::Win32DebugLogStream(){
|
||||
inline
|
||||
Win32DebugLogStream::Win32DebugLogStream(){
|
||||
// empty
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
inline
|
||||
inline
|
||||
Win32DebugLogStream::~Win32DebugLogStream(){
|
||||
// empty
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
inline
|
||||
inline
|
||||
void Win32DebugLogStream::write(const char* message) {
|
||||
::OutputDebugStringA( message);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ public:
|
|||
|
||||
static void BuildBoneList(aiNode *current_node, const aiNode *root_node,
|
||||
const aiScene *scene,
|
||||
std::vector<aiBone *> &bones);
|
||||
std::vector<aiBone *> &bones);
|
||||
|
||||
static void BuildBoneStack(aiNode *current_node, const aiNode *root_node,
|
||||
const aiScene *scene,
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ bool DropFaceNormalsProcess::DropMeshFaceNormals (aiMesh* mesh) {
|
|||
if (nullptr == mesh->mNormals) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
delete[] mesh->mNormals;
|
||||
mesh->mNormals = nullptr;
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -137,7 +137,7 @@ bool EmbedTexturesProcess::addTexture(aiScene *pScene, const std::string &path)
|
|||
pScene->mTextures = new aiTexture*[pScene->mNumTextures];
|
||||
::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u));
|
||||
delete [] oldTextures;
|
||||
|
||||
|
||||
// Add the new texture
|
||||
auto pTexture = new aiTexture;
|
||||
pTexture->mHeight = 0; // Means that this is still compressed
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ void FindDegeneratesProcess::Execute( aiScene* pScene) {
|
|||
if ( nullptr == pScene) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
std::unordered_map<unsigned int, unsigned int> meshMap;
|
||||
meshMap.reserve(pScene->mNumMeshes);
|
||||
|
||||
|
|
|
|||
|
|
@ -137,7 +137,7 @@ void FindInstancesProcess::Execute( aiScene* pScene)
|
|||
aiMesh* inst = pScene->mMeshes[i];
|
||||
hashes[i] = GetMeshHash(inst);
|
||||
|
||||
// Find an appropriate epsilon
|
||||
// Find an appropriate epsilon
|
||||
// to compare position differences against
|
||||
float epsilon = ComputePositionEpsilon(inst);
|
||||
epsilon *= epsilon;
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ public:
|
|||
|
||||
// -------------------------------------------------------------------
|
||||
/** 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. */
|
||||
static bool IsVerboseFormat(const aiScene* pScene);
|
||||
|
||||
|
|
|
|||
|
|
@ -215,7 +215,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
|
|||
}
|
||||
else
|
||||
{
|
||||
ASSIMP_LOG_INFO("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ",
|
||||
ASSIMP_LOG_INFO("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ",
|
||||
unreferencedRemoved, " unused materials.");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ void ScaleProcess::SetupProperties( const Importer* pImp ) {
|
|||
// File scaling * Application Scaling
|
||||
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.
|
||||
mScale *= importerScale;
|
||||
}
|
||||
|
|
@ -84,7 +84,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
if(mScale == 1.0f) {
|
||||
return; // nothing to scale
|
||||
}
|
||||
|
||||
|
||||
ai_assert( mScale != 0 );
|
||||
ai_assert( nullptr != pScene );
|
||||
ai_assert( nullptr != pScene->mRootNode );
|
||||
|
|
@ -96,7 +96,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
if ( nullptr == pScene->mRootNode ) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// Process animations and update position transform to new unit system
|
||||
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++)
|
||||
{
|
||||
aiNodeAnim* anim = animation->mChannels[animationChannel];
|
||||
|
||||
|
||||
for( unsigned int posKey = 0; posKey < anim->mNumPositionKeys; posKey++)
|
||||
{
|
||||
aiVectorKey& vectorKey = anim->mPositionKeys[posKey];
|
||||
|
|
@ -116,8 +116,8 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
|
||||
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
|
||||
for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++)
|
||||
{
|
||||
|
|
@ -129,9 +129,9 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
// bone placement / scaling
|
||||
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
|
||||
// be meaningful in some cases
|
||||
// be meaningful in some cases
|
||||
// like when you want the modeller to see 1:1 compatibility.
|
||||
aiBone* bone = mesh->mBones[boneID];
|
||||
|
||||
|
|
@ -139,10 +139,10 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
aiQuaternion rotation;
|
||||
|
||||
bone->mOffsetMatrix.Decompose( scale, rotation, pos);
|
||||
|
||||
|
||||
aiMatrix4x4 translation;
|
||||
aiMatrix4x4::Translation( pos * mScale, translation );
|
||||
|
||||
|
||||
aiMatrix4x4 scaling;
|
||||
aiMatrix4x4::Scaling( aiVector3D(scale), scaling );
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
for( unsigned int animMeshID = 0; animMeshID < mesh->mNumAnimMeshes; animMeshID++)
|
||||
{
|
||||
aiAnimMesh * animMesh = mesh->mAnimMeshes[animMeshID];
|
||||
|
||||
|
||||
for( unsigned int vertexID = 0; vertexID < animMesh->mNumVertices; vertexID++)
|
||||
{
|
||||
aiVector3D& vertex = animMesh->mVertices[vertexID];
|
||||
|
|
@ -169,31 +169,31 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|||
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 );
|
||||
|
||||
for( size_t i = 0; i < node->mNumChildren; i++)
|
||||
{
|
||||
// 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 ) {
|
||||
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
|
||||
// be meaningful in some cases
|
||||
// like when you want the modeller to
|
||||
// be meaningful in some cases
|
||||
// like when you want the modeller to
|
||||
// see 1:1 compatibility.
|
||||
|
||||
|
||||
aiVector3D pos, scale;
|
||||
aiQuaternion rotation;
|
||||
currentNode->mTransformation.Decompose( scale, rotation, pos);
|
||||
|
||||
|
||||
aiMatrix4x4 translation;
|
||||
aiMatrix4x4::Translation( pos * mScale, translation );
|
||||
|
||||
|
||||
aiMatrix4x4 scaling;
|
||||
|
||||
// note: we do not use mScale here, this is on purpose.
|
||||
|
|
|
|||
|
|
@ -55,8 +55,8 @@ namespace Assimp {
|
|||
// ---------------------------------------------------------------------------
|
||||
/** ScaleProcess: Class to rescale the whole model.
|
||||
* Now rescales animations, bones, and blend shapes properly.
|
||||
* Please note this will not write to 'scale' transform it will rewrite mesh
|
||||
* and matrixes so that your scale values
|
||||
* Please note this will not write to 'scale' transform it will rewrite mesh
|
||||
* and matrixes so that your scale values
|
||||
* from your model package are preserved, so this is completely intentional
|
||||
* bugs should be reported as soon as they are found.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -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
|
||||
// can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
|
||||
std::set<unsigned int> newBonesAtCurrentFace;
|
||||
|
||||
|
||||
const aiFace& face = pMesh->mFaces[a];
|
||||
// check every vertex if its bones would still fit into the current submesh
|
||||
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] )
|
||||
{
|
||||
newBonesAtCurrentFace.insert(boneIndex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -412,7 +412,7 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
|
|||
if (pMesh->mNumAnimMeshes > 0) {
|
||||
newMesh->mNumAnimMeshes = pMesh->mNumAnimMeshes;
|
||||
newMesh->mAnimMeshes = new aiAnimMesh*[newMesh->mNumAnimMeshes];
|
||||
|
||||
|
||||
for (unsigned int morphIdx = 0; morphIdx < newMesh->mNumAnimMeshes; ++morphIdx) {
|
||||
aiAnimMesh* origTarget = pMesh->mAnimMeshes[morphIdx];
|
||||
aiAnimMesh* newTarget = new aiAnimMesh;
|
||||
|
|
@ -421,16 +421,16 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
|
|||
newTarget->mNumVertices = numSubMeshVertices;
|
||||
newTarget->mVertices = new aiVector3D[numSubMeshVertices];
|
||||
newMesh->mAnimMeshes[morphIdx] = newTarget;
|
||||
|
||||
|
||||
if (origTarget->HasNormals()) {
|
||||
newTarget->mNormals = new aiVector3D[numSubMeshVertices];
|
||||
}
|
||||
|
||||
|
||||
if (origTarget->HasTangentsAndBitangents()) {
|
||||
newTarget->mTangents = new aiVector3D[numSubMeshVertices];
|
||||
newTarget->mBitangents = new aiVector3D[numSubMeshVertices];
|
||||
}
|
||||
|
||||
|
||||
for( unsigned int vi = 0; vi < numSubMeshVertices; ++vi) {
|
||||
// find the source vertex for it in the source mesh
|
||||
unsigned int previousIndex = previousVertexIndices[vi];
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
----------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/**
|
||||
/**
|
||||
* @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;
|
||||
|
||||
//Check for point cloud first,
|
||||
//Check for point cloud first,
|
||||
//Do not process point cloud, splitMesh works only with faces data
|
||||
for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
|
||||
if ( pScene->mMeshes[a]->mPrimitiveTypes == aiPrimitiveType_POINT ) {
|
||||
|
|
|
|||
|
|
@ -448,7 +448,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
|
|||
if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
|
||||
|
||||
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");
|
||||
}
|
||||
size = AI_MAX_NUMBER_OF_TEXTURECOORDS;
|
||||
|
|
|
|||
|
|
@ -86,11 +86,11 @@ namespace {
|
|||
|
||||
/**
|
||||
* @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
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* @param tri Triangle to encode.
|
||||
*/
|
||||
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.
|
||||
*
|
||||
*
|
||||
* @param tri1 First quad triangle
|
||||
* @param tri2 Second quad triangle
|
||||
*
|
||||
*
|
||||
* @pre Triangles must be properly fanned from the most appropriate vertex.
|
||||
*/
|
||||
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.
|
||||
*
|
||||
*
|
||||
* @param tri Current triangle.
|
||||
* @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.
|
||||
|
|
@ -512,7 +512,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
|
|||
num = 0;
|
||||
break;
|
||||
|
||||
/*curOut -= (max-num); // undo all previous work
|
||||
/*curOut -= (max-num); // undo all previous work
|
||||
for (tmp = 0; tmp < max-2; ++tmp) {
|
||||
aiFace& nface = *curOut++;
|
||||
|
||||
|
|
|
|||
18
doc/dox.h
18
doc/dox.h
|
|
@ -90,8 +90,8 @@ but not all of them are *open-source*. If there's an accompagning '<file>\source
|
|||
@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
|
||||
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
|
||||
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
|
||||
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:
|
||||
|
||||
|
|
@ -145,7 +145,7 @@ to your include paths (Menu->Extras->Options->Projects and Solutions-&g
|
|||
and the assimp/lib/<Compiler> path to your linker paths (Menu->Extras->Options->Projects and Solutions->VC++ Directories->Library files).
|
||||
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
|
||||
|
||||
@code
|
||||
|
|
@ -158,7 +158,7 @@ Now just add the assimp-dependency to your application:
|
|||
TARGET_LINK_LIBRARIES(my_game assimp)
|
||||
@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
|
||||
|
|
@ -170,7 +170,7 @@ to build the library just open a command-prompt / bash, navigate into the repo-f
|
|||
cmake CMakeLists.txt
|
||||
@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.
|
||||
|
||||
@section assimp_dll Windows DLL Build
|
||||
|
|
@ -496,10 +496,10 @@ X3 Y3 Z3 T3
|
|||
@endcode
|
||||
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
|
||||
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
|
||||
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>.
|
||||
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>.
|
||||
|
||||
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
|
||||
|
|
@ -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].
|
||||
</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 ).
|
||||
</li>
|
||||
<li>
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
@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.
|
||||
<br><br>
|
||||
<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:
|
||||
|
||||
<table border="1">
|
||||
|
||||
|
||||
<tr>
|
||||
<td><b>@link version version @endlink</b></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
|
||||
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
|
||||
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.
|
||||
|
||||
<h3>Syntax:</h3>
|
||||
|
|
@ -199,7 +199,7 @@ assimp dump <model> [<out>] [-b] [-s] [common parameters]
|
|||
<p>
|
||||
<tt>
|
||||
model<br></tt><br>
|
||||
Required. Relative or absolute path to the input model.
|
||||
Required. Relative or absolute path to the input model.
|
||||
</p>
|
||||
<p>
|
||||
<tt>
|
||||
|
|
@ -220,7 +220,7 @@ The long form of this parameter is <tt>--binary</tt>.
|
|||
</tt><br>
|
||||
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
|
||||
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
|
||||
a fast way to verify whether a loader works correctly or not.
|
||||
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>
|
||||
<tt>
|
||||
common parameters<br></tt><br>
|
||||
Optional. Import configuration & postprocessing.
|
||||
Optional. Import configuration & postprocessing.
|
||||
See the @link common common parameters page @endlink for more information.
|
||||
</p>
|
||||
|
||||
|
|
@ -248,7 +248,7 @@ The log output is included with the dump.
|
|||
|
||||
@code
|
||||
assimp dump files\*.*
|
||||
assimp dump files\*.*
|
||||
assimp dump files\*.*
|
||||
@endcode
|
||||
|
||||
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>
|
||||
<tt>
|
||||
model<br></tt><br>
|
||||
Required. Relative or absolute path to the input model.
|
||||
Required. Relative or absolute path to the input model.
|
||||
</p>
|
||||
<p>
|
||||
<tt>
|
||||
out<br></tt><br>
|
||||
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>
|
||||
The suffix <tt>_img<n></tt> is appended to the file name if the -s switch is not specified
|
||||
The suffix <tt>_img<n></tt> is appended to the file name if the -s switch is not specified
|
||||
(where <tt><n></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
|
||||
|
|
@ -296,7 +296,7 @@ written in their native file format (e.g. jpg).
|
|||
<p>
|
||||
<tt>-t<n><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 long form of this parameter is <tt>--texture=<n></tt>.
|
||||
</p>
|
||||
|
|
@ -348,8 +348,8 @@ imported data structure and writes it to <tt>test_img0.bmp</tt>.
|
|||
|
||||
|
||||
@code
|
||||
assimp extract files\*.mdl *.bmp
|
||||
assimp extract files\*.mdl *.bmp
|
||||
assimp extract files\*.mdl *.bmp
|
||||
assimp extract files\*.mdl *.bmp
|
||||
@endcode
|
||||
|
||||
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
|
||||
|
||||
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
|
||||
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.
|
||||
|
||||
<table border="1">
|
||||
|
|
@ -376,7 +376,7 @@ more information can be found in the <tt>aiPostProcess.h</tt> header.
|
|||
<tr>
|
||||
<td><tt>-ptv</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>
|
||||
</tr>
|
||||
<tr>
|
||||
|
|
@ -428,7 +428,7 @@ more information can be found in the <tt>aiPostProcess.h</tt> header.
|
|||
<tr>
|
||||
<td><tt>-icl</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>
|
||||
</tr>
|
||||
<tr>
|
||||
|
|
@ -515,7 +515,7 @@ For convenience some default postprocessing configurations are provided.
|
|||
The corresponding command line parameter is <tt>-c<name></tt> (or <tt>--config=<name></tt>).
|
||||
|
||||
<table border="1">
|
||||
|
||||
|
||||
<tr>
|
||||
<th>Name</th>
|
||||
<th>Description</th>
|
||||
|
|
@ -543,7 +543,7 @@ The corresponding command line parameter is <tt>-c<name></tt> (or <tt>--co
|
|||
There are also some common flags to customize Assimp's logging behaviour:
|
||||
|
||||
<table border="1">
|
||||
|
||||
|
||||
<tr>
|
||||
<th>Name</th>
|
||||
<th>Description</th>
|
||||
|
|
@ -558,7 +558,7 @@ There are also some common flags to customize Assimp's logging behaviour:
|
|||
</tr>
|
||||
<tr>
|
||||
<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>
|
||||
</tr>
|
||||
</table>
|
||||
|
|
|
|||
|
|
@ -54,6 +54,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize) {
|
|||
aiProcessPreset_TargetRealtime_Quality, nullptr );
|
||||
|
||||
aiDetachLogStream(&stream);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ public:
|
|||
/** Returns the exception of the last exception that occurred.
|
||||
* Note: Exceptions are not the only source of error details, so GetErrorText
|
||||
* should be consulted too.
|
||||
* @return The last exception that occurred.
|
||||
* @return The last exception that occurred.
|
||||
*/
|
||||
const std::exception_ptr& GetException() const {
|
||||
return m_Exception;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
// ===============================================================================
|
||||
// May be included multiple times - resets structure packing to the defaults
|
||||
// for all supported compilers. Reverts the changes made by #include <pushpack1.h>
|
||||
// May be included multiple times - resets structure packing to the defaults
|
||||
// for all supported compilers. Reverts the changes made by #include <pushpack1.h>
|
||||
//
|
||||
// Currently this works on the following compilers:
|
||||
// MSVC 7,8,9
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
|
||||
// ===============================================================================
|
||||
// May be included multiple times - sets structure packing to 1
|
||||
// May be included multiple times - sets structure packing to 1
|
||||
// for all supported compilers. #include <poppack1.h> reverts the changes.
|
||||
//
|
||||
// Currently this works on the following compilers:
|
||||
|
|
@ -37,7 +37,7 @@
|
|||
|
||||
#if defined(_MSC_VER)
|
||||
// C4103: Packing was changed after the inclusion of the header, probably missing #pragma pop
|
||||
# pragma warning (disable : 4103)
|
||||
# pragma warning (disable : 4103)
|
||||
#endif
|
||||
|
||||
#define AI_PUSHPACK_IS_DEFINED
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ using std::runtime_error;
|
|||
class ASSIMP_API DeadlyErrorBase : public runtime_error {
|
||||
protected:
|
||||
DeadlyErrorBase(Assimp::Formatter::format f);
|
||||
|
||||
|
||||
template<typename... T, typename U>
|
||||
DeadlyErrorBase(Assimp::Formatter::format f, U&& u, T&&... args) :
|
||||
DeadlyErrorBase(std::move(f << std::forward<U>(u)), std::forward<T>(args)...) {}
|
||||
|
|
|
|||
|
|
@ -390,7 +390,7 @@ public:
|
|||
* @see SetPropertyInteger()
|
||||
*/
|
||||
bool SetPropertyMatrix(const char *szName, const aiMatrix4x4 &sValue);
|
||||
|
||||
|
||||
bool SetPropertyCallback(const char *szName, const std::function<void *(void *)> &f);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ public:
|
|||
/// @brief Returns the file-size.
|
||||
/// @return The file-size.
|
||||
size_t size() const;
|
||||
|
||||
|
||||
/// @brief Returns the cache size.
|
||||
/// @return The cache size.
|
||||
size_t cacheSize() const;
|
||||
|
|
@ -278,7 +278,7 @@ bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationT
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
buffer[ i ] = '\n';
|
||||
++m_cachePos;
|
||||
|
||||
|
|
@ -334,7 +334,7 @@ template<class T>
|
|||
AI_FORCE_INLINE
|
||||
bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
|
||||
// Return the last block-value if getNextLine was used before
|
||||
if ( 0 != m_cachePos ) {
|
||||
if ( 0 != m_cachePos ) {
|
||||
buffer = std::vector<T>( m_cache.begin() + m_cachePos, m_cache.end() );
|
||||
m_cachePos = 0;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -62,9 +62,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include "types.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
# include <direct.h>
|
||||
# include <stdlib.h>
|
||||
# include <stdio.h>
|
||||
# include <direct.h>
|
||||
# include <stdlib.h>
|
||||
# include <stdio.h>
|
||||
#else
|
||||
# include <sys/stat.h>
|
||||
# include <sys/types.h>
|
||||
|
|
@ -84,7 +84,7 @@ namespace Assimp {
|
|||
* to the importer library. If you implement this interface, you also want to
|
||||
* supply a custom implementation for IOStream.
|
||||
*
|
||||
* @see Importer::SetIOHandler()
|
||||
* @see Importer::SetIOHandler()
|
||||
*/
|
||||
class ASSIMP_API IOSystem
|
||||
#ifndef SWIG
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ public:
|
|||
/** @brief Writes a debug message
|
||||
* @param message Debug message*/
|
||||
void verboseDebug(const char* message);
|
||||
|
||||
|
||||
template<typename... T>
|
||||
void verboseDebug(T&&... args) {
|
||||
verboseDebug(formatMessage(std::forward<T>(args)...).c_str());
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <stdint.h>
|
||||
|
||||
namespace Assimp {
|
||||
|
||||
|
||||
#define AI_MEMORYIO_MAGIC_FILENAME "$$$___magic___$$$"
|
||||
#define AI_MEMORYIO_MAGIC_FILENAME_LENGTH 17
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ public:
|
|||
size_t Read(void* pvBuffer, size_t pSize, size_t pCount) {
|
||||
ai_assert(nullptr != pvBuffer);
|
||||
ai_assert(0 != pSize);
|
||||
|
||||
|
||||
const size_t cnt = std::min( pCount, (length-pos) / pSize);
|
||||
const size_t ofs = pSize * cnt;
|
||||
|
||||
|
|
@ -209,7 +209,7 @@ public:
|
|||
return existing_io ? existing_io->ComparePaths(one, second) : false;
|
||||
}
|
||||
|
||||
bool PushDirectory( const std::string &path ) override {
|
||||
bool PushDirectory( const std::string &path ) override {
|
||||
return existing_io ? existing_io->PushDirectory(path) : false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -53,17 +53,17 @@ Based on CppCon 2016: Chandler Carruth "High Performance Code 201: Hybrid Data S
|
|||
namespace Assimp {
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
/// @brief Small vector with inplace storage.
|
||||
/// @brief Small vector with inplace storage.
|
||||
///
|
||||
/// Reduces heap allocations when list is shorter. It uses a small array for a dedicated size.
|
||||
/// When the growing gets bigger than this small cache a dynamic growing algorithm will be
|
||||
/// When the growing gets bigger than this small cache a dynamic growing algorithm will be
|
||||
/// used.
|
||||
// --------------------------------------------------------------------------------------------
|
||||
template<typename T, unsigned int Capacity>
|
||||
class SmallVector {
|
||||
public:
|
||||
/// @brief The default class constructor.
|
||||
SmallVector() :
|
||||
SmallVector() :
|
||||
mStorage(mInplaceStorage),
|
||||
mSize(0),
|
||||
mCapacity(Capacity) {
|
||||
|
|
@ -84,7 +84,7 @@ public:
|
|||
mStorage[mSize++] = item;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
push_back_and_grow(item);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ Copyright (c) 2006-2021, assimp team
|
|||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
|
|
@ -25,16 +25,16 @@ conditions are met:
|
|||
derived from this software without specific prior
|
||||
written permission of the assimp team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -77,7 +77,7 @@ void ComputeNormalsWithSmoothingsGroups(MeshWithSmoothingGroups<T>& sMesh)
|
|||
sMesh.mNormals[face.mIndices[c]] = vNor;
|
||||
}
|
||||
|
||||
// calculate the position bounds so we have a reliable epsilon to check position differences against
|
||||
// calculate the position bounds so we have a reliable epsilon to check position differences against
|
||||
aiVector3D minVec( 1e10f, 1e10f, 1e10f), maxVec( -1e10f, -1e10f, -1e10f);
|
||||
for( unsigned int a = 0; a < sMesh.mPositions.size(); a++)
|
||||
{
|
||||
|
|
@ -91,7 +91,7 @@ void ComputeNormalsWithSmoothingsGroups(MeshWithSmoothingGroups<T>& sMesh)
|
|||
const float posEpsilon = (maxVec - minVec).Length() * 1e-5f;
|
||||
std::vector<aiVector3D> avNormals;
|
||||
avNormals.resize(sMesh.mNormals.size());
|
||||
|
||||
|
||||
// now generate the spatial sort tree
|
||||
SGSpatialSort sSort;
|
||||
for( typename std::vector<T>::iterator i = sMesh.mFaces.begin();
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ using XmlAttribute = pugi::xml_attribute;
|
|||
/// }
|
||||
/// }
|
||||
/// @endcode
|
||||
/// @tparam TNodeType
|
||||
/// @tparam TNodeType
|
||||
template <class TNodeType>
|
||||
class TXmlParser {
|
||||
public:
|
||||
|
|
@ -123,7 +123,7 @@ public:
|
|||
|
||||
/// @brief Will search for a child-node by its name
|
||||
/// @param name [in] The name of the child-node.
|
||||
/// @return The node instance or nullptr, if nothing was found.
|
||||
/// @return The node instance or nullptr, if nothing was found.
|
||||
TNodeType *findNode(const std::string &name) {
|
||||
if (name.empty()) {
|
||||
return nullptr;
|
||||
|
|
@ -162,12 +162,12 @@ public:
|
|||
mData.resize(len + 1);
|
||||
memset(&mData[0], '\0', len + 1);
|
||||
stream->Read(&mData[0], 1, len);
|
||||
|
||||
|
||||
mDoc = new pugi::xml_document();
|
||||
pugi::xml_parse_result parse_result = mDoc->load_string(&mData[0], pugi::parse_full);
|
||||
if (parse_result.status == pugi::status_ok) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
ASSIMP_LOG_DEBUG("Error while parse xml.", std::string(parse_result.description()), " @ ", parse_result.offset);
|
||||
|
||||
|
|
@ -457,7 +457,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
XmlNode &mParent;
|
||||
XmlNode &mParent;
|
||||
std::vector<XmlNode> mNodes;
|
||||
size_t mIndex;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ namespace Assimp
|
|||
|
||||
#else
|
||||
# define ai_assert(expression)
|
||||
# define ai_assert_entry()
|
||||
# define ai_assert_entry()
|
||||
#endif // ASSIMP_BUILD_DEBUG
|
||||
|
||||
#endif // AI_ASSERT_H_INC
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/**
|
||||
/**
|
||||
* @file anim.h
|
||||
* @brief Defines the data structures in which the imported animations
|
||||
* are returned.
|
||||
|
|
@ -478,11 +478,11 @@ struct aiAnimation {
|
|||
namespace Assimp {
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/**
|
||||
/**
|
||||
* @brief CPP-API: Utility class to simplify interpolations of various data types.
|
||||
*
|
||||
* The type of interpolation is chosen automatically depending on the
|
||||
* types of the arguments.
|
||||
* types of the arguments.
|
||||
*/
|
||||
template <typename T>
|
||||
struct Interpolator {
|
||||
|
|
|
|||
|
|
@ -894,7 +894,7 @@ ASSIMP_API float aiMatrix3Determinant(
|
|||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Get a 3x3 rotation matrix around the Z axis.
|
||||
* @param mat Receives the output matrix
|
||||
* @param mat Receives the output matrix
|
||||
* @param angle Rotation angle, in radians
|
||||
*/
|
||||
ASSIMP_API void aiMatrix3RotationZ(
|
||||
|
|
@ -903,7 +903,7 @@ ASSIMP_API void aiMatrix3RotationZ(
|
|||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Returns a 3x3 rotation matrix for a rotation around an arbitrary axis.
|
||||
* @param mat Receives the output matrix
|
||||
* @param mat Receives the output matrix
|
||||
* @param axis Rotation axis, should be a normalized vector
|
||||
* @param angle Rotation angle, in radians
|
||||
*/
|
||||
|
|
@ -914,7 +914,7 @@ ASSIMP_API void aiMatrix3FromRotationAroundAxis(
|
|||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Get a 3x3 translation matrix.
|
||||
* @param mat Receives the output matrix
|
||||
* @param mat Receives the output matrix
|
||||
* @param translation The translation vector
|
||||
*/
|
||||
ASSIMP_API void aiMatrix3Translation(
|
||||
|
|
@ -923,7 +923,7 @@ ASSIMP_API void aiMatrix3Translation(
|
|||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Create a 3x3 matrix that rotates one vector to another vector.
|
||||
* @param mat Receives the output matrix
|
||||
* @param mat Receives the output matrix
|
||||
* @param from Vector to rotate from
|
||||
* @param to Vector to rotate to
|
||||
*/
|
||||
|
|
@ -1059,7 +1059,7 @@ ASSIMP_API void aiMatrix4DecomposeNoScaling(
|
|||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Creates a 4x4 matrix from a set of euler angles.
|
||||
* @param mat Receives the output matrix
|
||||
* @param mat Receives the output matrix
|
||||
* @param x Rotation angle for the x-axis, in radians
|
||||
* @param y Rotation angle for the y-axis, in radians
|
||||
* @param z Rotation angle for the z-axis, in radians
|
||||
|
|
@ -1137,7 +1137,7 @@ ASSIMP_API void aiMatrix4FromTo(
|
|||
|
||||
// --------------------------------------------------------------------------------
|
||||
/** Create a Quaternion from euler angles.
|
||||
* @param q Receives the output quaternion
|
||||
* @param q Receives the output quaternion
|
||||
* @param x Rotation angle for the x-axis, in radians
|
||||
* @param y Rotation angle for the y-axis, in radians
|
||||
* @param z Rotation angle for the z-axis, in radians
|
||||
|
|
|
|||
|
|
@ -161,7 +161,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#pragma warning(disable : 4251)
|
||||
#endif
|
||||
/* Force the compiler to inline a function, if possible */
|
||||
#define AI_FORCE_INLINE inline
|
||||
#define AI_FORCE_INLINE inline
|
||||
|
||||
/* Tells the compiler that a function never returns. Used in code analysis
|
||||
* to skip dead paths (e.g. after an assertion evaluated to false). */
|
||||
|
|
|
|||
|
|
@ -257,7 +257,7 @@ struct aiLight
|
|||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#endif // !! AI_LIGHT_H_INC
|
||||
|
|
|
|||
|
|
@ -194,8 +194,8 @@ enum aiTextureType {
|
|||
*/
|
||||
aiTextureType_NONE = 0,
|
||||
|
||||
/** LEGACY API MATERIALS
|
||||
* Legacy refers to materials which
|
||||
/** LEGACY API MATERIALS
|
||||
* Legacy refers to materials which
|
||||
* Were originally implemented in the specifications around 2000.
|
||||
* These must never be removed, as most engines support them.
|
||||
*/
|
||||
|
|
@ -339,9 +339,9 @@ ASSIMP_API const char *TextureTypeToString(enum aiTextureType in);
|
|||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** @brief Defines all shading models supported by the library
|
||||
*
|
||||
*
|
||||
* Property: #AI_MATKEY_SHADING_MODEL
|
||||
*
|
||||
*
|
||||
* The list of shading modes has been taken from Blender.
|
||||
* See Blender documentation for more information. The API does
|
||||
* not distinguish between "specular" and "diffuse" shaders (thus the
|
||||
|
|
|
|||
|
|
@ -230,7 +230,7 @@ public:
|
|||
* @param out Receives the output matrix
|
||||
* @return Reference to the output matrix
|
||||
*/
|
||||
static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v,
|
||||
static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v,
|
||||
aiMatrix4x4t& out);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -421,7 +421,7 @@ void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TRea
|
|||
and post-multiplication of column vectors,
|
||||
the rotation matrix for an euler XYZ rotation is M = Rz * Ry * Rx.
|
||||
combining gives:
|
||||
|
||||
|
||||
| CE BDE-AF ADE+BF 0 |
|
||||
M = | CF BDF+AE ADF-BE 0 |
|
||||
| -D CB AC 0 |
|
||||
|
|
|
|||
|
|
@ -400,17 +400,17 @@ enum aiPrimitiveType {
|
|||
|
||||
/**
|
||||
* A flag to determine whether this triangles only mesh is NGON encoded.
|
||||
*
|
||||
*
|
||||
* NGON encoding is a special encoding that tells whether 2 or more consecutive triangles
|
||||
* should be considered as a triangle fan. This is identified by looking at the first vertex index.
|
||||
* 2 consecutive triangles with the same 1st vertex index are part of the same
|
||||
* NGON.
|
||||
*
|
||||
* At the moment, only quads (concave or convex) are supported, meaning that polygons are 'seen' as
|
||||
*
|
||||
* At the moment, only quads (concave or convex) are supported, meaning that polygons are 'seen' as
|
||||
* triangles, as usual after a triangulation pass.
|
||||
*
|
||||
*
|
||||
* To get an NGON encoded mesh, please use the aiProcess_Triangulate post process.
|
||||
*
|
||||
*
|
||||
* @see aiProcess_Triangulate
|
||||
* @link https://github.com/KhronosGroup/glTF/pull/1620
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -211,10 +211,10 @@ enum aiPostProcessSteps
|
|||
*
|
||||
* If the resulting scene can be reduced to a single mesh, with a single
|
||||
* material, no lights, and no cameras, then the output scene will contain
|
||||
* only a root node (with no children) that references the single mesh.
|
||||
* only a root node (with no children) that references the single mesh.
|
||||
* Otherwise, the output scene will be reduced to a root node with a single
|
||||
* level of child nodes, each one referencing one mesh, and each mesh
|
||||
* referencing one material.
|
||||
* level of child nodes, each one referencing one mesh, and each mesh
|
||||
* referencing one material.
|
||||
*
|
||||
* In either case, for rendering, you can
|
||||
* simply render all meshes in order - you don't need to pay
|
||||
|
|
@ -328,12 +328,12 @@ enum aiPostProcessSteps
|
|||
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
/**
|
||||
/**
|
||||
* This step generically populates aiBone->mArmature and aiBone->mNode generically
|
||||
* The point of these is it saves you later having to calculate these elements
|
||||
* This is useful when handling rest information or skin information
|
||||
* If you have multiple armatures on your models we strongly recommend enabling this
|
||||
* Instead of writing your own multi-root, multi-armature lookups we have done the
|
||||
* If you have multiple armatures on your models we strongly recommend enabling this
|
||||
* Instead of writing your own multi-root, multi-armature lookups we have done the
|
||||
* hard work for you :)
|
||||
*/
|
||||
aiProcess_PopulateArmatureData = 0x4000,
|
||||
|
|
@ -579,7 +579,7 @@ enum aiPostProcessSteps
|
|||
* of the imported model. And if so, it uses that.
|
||||
*/
|
||||
aiProcess_EmbedTextures = 0x10000000,
|
||||
|
||||
|
||||
// aiProcess_GenEntityMeshes = 0x100000,
|
||||
// aiProcess_OptimizeAnimations = 0x200000
|
||||
// aiProcess_FixTexturePaths = 0x200000
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue