Merge branch 'master' into bound
Kim Kulling
GitHub
commit
27231c3f52
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ namespace XmlTag {
|
|||
const char* const PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
|
||||
const char* const PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
|
||||
const char* const PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
|
||||
}
|
||||
}
|
||||
|
||||
} // Namespace D3MF
|
||||
} // Namespace Assimp
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -231,11 +231,7 @@ void ColladaParser::UriDecodePath(aiString &ss) {
|
|||
|
||||
// Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
|
||||
// I need to filter it without destroying linux paths starting with "/somewhere"
|
||||
#if defined(_MSC_VER)
|
||||
if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
|
||||
#else
|
||||
if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
|
||||
#endif
|
||||
--ss.length;
|
||||
::memmove(ss.data, ss.data + 1, ss.length);
|
||||
ss.data[ss.length] = 0;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
@ -516,13 +516,13 @@ namespace pmx
|
|||
stream->read((char*) magic, sizeof(char) * 4);
|
||||
if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
|
||||
{
|
||||
throw DeadlyImportError("MMD: Invalid magic number.");
|
||||
}
|
||||
throw DeadlyImportError("MMD: Invalid magic number.");
|
||||
}
|
||||
stream->read((char*) &version, sizeof(float));
|
||||
if (version != 2.0f && version != 2.1f)
|
||||
{
|
||||
throw DeadlyImportError("MMD: Unsupported version (must be 2.0 or 2.1): ", ai_to_string(version));
|
||||
}
|
||||
}
|
||||
this->setting.Read(stream);
|
||||
|
||||
this->model_name = ReadString(stream, setting.encoding);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -58,13 +58,13 @@ using namespace Assimp;
|
|||
namespace EXPRESS = STEP::EXPRESS;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = "")
|
||||
std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = std::string())
|
||||
{
|
||||
return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(line ",line,") ",s) );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = "")
|
||||
std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = std::string())
|
||||
{
|
||||
return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(entity #",entity,") ",s));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -175,12 +175,11 @@ void StepExporter::WriteFile()
|
|||
fColor.b = 0.8f;
|
||||
|
||||
int ind = 100; // the start index to be used
|
||||
int faceEntryLen = 30; // number of entries for a triangle/face
|
||||
std::vector<int> faceEntryLen; // numbers of entries for a triangle/face
|
||||
// prepare unique (count triangles and vertices)
|
||||
|
||||
VectorIndexUMap uniqueVerts; // use a map to reduce find complexity to log(n)
|
||||
VectorIndexUMap::iterator it;
|
||||
int countFace = 0;
|
||||
|
||||
for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
|
||||
{
|
||||
|
|
@ -189,7 +188,7 @@ void StepExporter::WriteFile()
|
|||
{
|
||||
aiFace* face = &(mesh->mFaces[j]);
|
||||
|
||||
if (face->mNumIndices == 3) countFace++;
|
||||
if (face->mNumIndices >= 3) faceEntryLen.push_back(15 + 5 * face->mNumIndices);
|
||||
}
|
||||
for (unsigned int j=0; j<mesh->mNumVertices; ++j)
|
||||
{
|
||||
|
|
@ -218,10 +217,13 @@ void StepExporter::WriteFile()
|
|||
// write the top of data
|
||||
mOutput << "DATA" << endstr;
|
||||
mOutput << "#1=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(' ',(";
|
||||
for (int i=0; i<countFace; ++i)
|
||||
size_t countFace = faceEntryLen.size();
|
||||
size_t faceLenIndex = ind + 2 * uniqueVerts.size();
|
||||
for (size_t i=0; i<countFace; ++i)
|
||||
{
|
||||
mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size();
|
||||
mOutput << "#" << faceLenIndex;
|
||||
if (i!=countFace-1) mOutput << ",";
|
||||
faceLenIndex += faceEntryLen[i];
|
||||
}
|
||||
mOutput << "),#6)" << endstr;
|
||||
|
||||
|
|
@ -253,10 +255,12 @@ void StepExporter::WriteFile()
|
|||
mOutput << "#27=DIRECTION('',(1.0,0.0,0.0))" << endstr;
|
||||
mOutput << "#28= (NAMED_UNIT(#21)LENGTH_UNIT()SI_UNIT(.MILLI.,.METRE.))" << endstr;
|
||||
mOutput << "#29=CLOSED_SHELL('',(";
|
||||
for (int i=0; i<countFace; ++i)
|
||||
faceLenIndex = ind + 2 * uniqueVerts.size() + 8;
|
||||
for (size_t i=0; i<countFace; ++i)
|
||||
{
|
||||
mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size() + 8;
|
||||
mOutput << "#" << faceLenIndex;
|
||||
if (i!=countFace-1) mOutput << ",";
|
||||
faceLenIndex += faceEntryLen[i];
|
||||
}
|
||||
mOutput << "))" << endstr;
|
||||
|
||||
|
|
@ -289,28 +293,29 @@ void StepExporter::WriteFile()
|
|||
{
|
||||
aiFace* face = &(mesh->mFaces[j]);
|
||||
|
||||
if (face->mNumIndices != 3) continue;
|
||||
const int numIndices = face->mNumIndices;
|
||||
if (numIndices < 3) continue;
|
||||
|
||||
aiVector3D* v1 = &(mesh->mVertices[face->mIndices[0]]);
|
||||
aiVector3D* v2 = &(mesh->mVertices[face->mIndices[1]]);
|
||||
aiVector3D* v3 = &(mesh->mVertices[face->mIndices[2]]);
|
||||
aiVector3D dv12 = *v2 - *v1;
|
||||
aiVector3D dv23 = *v3 - *v2;
|
||||
aiVector3D dv31 = *v1 - *v3;
|
||||
aiVector3D dv13 = *v3 - *v1;
|
||||
dv12.Normalize();
|
||||
dv23.Normalize();
|
||||
dv31.Normalize();
|
||||
dv13.Normalize();
|
||||
std::vector<int> pidArray(numIndices, -1); // vertex id
|
||||
std::vector<aiVector3D> dvArray(numIndices); // edge dir
|
||||
for (int k = 0; k < numIndices; ++k)
|
||||
{
|
||||
aiVector3D *v1 = &(mesh->mVertices[face->mIndices[k]]);
|
||||
pidArray[k] = uniqueVerts.find(v1)->second;
|
||||
|
||||
aiVector3D dvY = dv12;
|
||||
aiVector3D dvX = dvY ^ dv13;
|
||||
aiVector3D *v2 = nullptr;
|
||||
if (k + 1 == numIndices)
|
||||
v2 = &(mesh->mVertices[face->mIndices[0]]);
|
||||
else
|
||||
v2 = &(mesh->mVertices[face->mIndices[k + 1]]);
|
||||
dvArray[k] = *v2 - *v1;
|
||||
dvArray[k].Normalize();
|
||||
}
|
||||
|
||||
aiVector3D dvY = dvArray[1];
|
||||
aiVector3D dvX = dvY ^ dvArray[0];
|
||||
dvX.Normalize();
|
||||
|
||||
int pid1 = uniqueVerts.find(v1)->second;
|
||||
int pid2 = uniqueVerts.find(v2)->second;
|
||||
int pid3 = uniqueVerts.find(v3)->second;
|
||||
|
||||
// mean vertex color for the face if available
|
||||
if (mesh->HasVertexColors(0))
|
||||
{
|
||||
|
|
@ -339,35 +344,62 @@ void StepExporter::WriteFile()
|
|||
|
||||
/* 2 directions of the plane */
|
||||
mOutput << "#" << sid+9 << "=PLANE('',#" << sid+10 << ")" << endstr;
|
||||
mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pid1 << ", #" << sid+11 << ",#" << sid+12 << ")" << endstr;
|
||||
mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pidArray[0] << ",#" << sid+11 << ",#" << sid+12 << ")" << endstr;
|
||||
|
||||
mOutput << "#" << sid + 11 << "=DIRECTION('',(" << dvX.x << "," << dvX.y << "," << dvX.z << "))" << endstr;
|
||||
mOutput << "#" << sid + 12 << "=DIRECTION('',(" << dvY.x << "," << dvY.y << "," << dvY.z << "))" << endstr;
|
||||
|
||||
mOutput << "#" << sid+13 << "=FACE_BOUND('',#" << sid+14 << ",.T.)" << endstr;
|
||||
mOutput << "#" << sid+14 << "=EDGE_LOOP('',(#" << sid+15 << ",#" << sid+16 << ",#" << sid+17 << "))" << endstr;
|
||||
mOutput << "#" << sid+14 << "=EDGE_LOOP('',(";
|
||||
int edgeLoopStart = sid + 15;
|
||||
for (int k = 0; k < numIndices; ++k)
|
||||
{
|
||||
if (k == 0)
|
||||
mOutput << "#";
|
||||
else
|
||||
mOutput << ",#";
|
||||
mOutput << edgeLoopStart + k;
|
||||
}
|
||||
mOutput << "))" << endstr;
|
||||
|
||||
/* edge loop */
|
||||
mOutput << "#" << sid+15 << "=ORIENTED_EDGE('',*,*,#" << sid+18 << ",.T.)" << endstr;
|
||||
mOutput << "#" << sid+16 << "=ORIENTED_EDGE('',*,*,#" << sid+19 << ",.T.)" << endstr;
|
||||
mOutput << "#" << sid+17 << "=ORIENTED_EDGE('',*,*,#" << sid+20 << ",.T.)" << endstr;
|
||||
int orientedEdgesStart = edgeLoopStart + numIndices;
|
||||
for (int k=0; k < numIndices; k++)
|
||||
{
|
||||
mOutput << "#" << edgeLoopStart+k << "=ORIENTED_EDGE('',*,*,#" << orientedEdgesStart + k << ",.T.)" << endstr;
|
||||
}
|
||||
|
||||
/* oriented edges */
|
||||
mOutput << "#" << sid+18 << "=EDGE_CURVE('',#" << pid1+1 << ",#" << pid2+1 << ",#" << sid+21 << ",.F.)" << endstr;
|
||||
mOutput << "#" << sid+19 << "=EDGE_CURVE('',#" << pid2+1 << ",#" << pid3+1 << ",#" << sid+22 << ",.T.)" << endstr;
|
||||
mOutput << "#" << sid+20 << "=EDGE_CURVE('',#" << pid3+1 << ",#" << pid1+1 << ",#" << sid+23 << ",.T.)" << endstr;
|
||||
int lineStart = orientedEdgesStart + numIndices;
|
||||
for (int k=0; k < numIndices; ++k)
|
||||
{
|
||||
if (k == 0)
|
||||
mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[k+1]+1 << ",#" << lineStart+k << ",.F.)" << endstr;
|
||||
else if (k+1 == numIndices)
|
||||
mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[0]+1 << ",#" << lineStart+k << ",.T.)" << endstr;
|
||||
else
|
||||
mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[k+1]+1 << ",#" << lineStart+k << ",.T.)" << endstr;
|
||||
}
|
||||
|
||||
/* 3 lines and 3 vectors for the lines for the 3 edge curves */
|
||||
mOutput << "#" << sid+21 << "=LINE('',#" << pid1 << ",#" << sid+24 << ")" << endstr;
|
||||
mOutput << "#" << sid+22 << "=LINE('',#" << pid2 << ",#" << sid+25 << ")" << endstr;
|
||||
mOutput << "#" << sid+23 << "=LINE('',#" << pid3 << ",#" << sid+26 << ")" << endstr;
|
||||
mOutput << "#" << sid+24 << "=VECTOR('',#" << sid+27 << ",1.0)" << endstr;
|
||||
mOutput << "#" << sid+25 << "=VECTOR('',#" << sid+28 << ",1.0)" << endstr;
|
||||
mOutput << "#" << sid+26 << "=VECTOR('',#" << sid+29 << ",1.0)" << endstr;
|
||||
mOutput << "#" << sid+27 << "=DIRECTION('',(" << dv12.x << "," << dv12.y << "," << dv12.z << "))" << endstr;
|
||||
mOutput << "#" << sid+28 << "=DIRECTION('',(" << dv23.x << "," << dv23.y << "," << dv23.z << "))" << endstr;
|
||||
mOutput << "#" << sid+29 << "=DIRECTION('',(" << dv31.x << "," << dv31.y << "," << dv31.z << "))" << endstr;
|
||||
ind += faceEntryLen; // increase counter
|
||||
/* n lines and n vectors for the lines for the n edge curves */
|
||||
int vectorStart = lineStart + numIndices;
|
||||
for (int k=0; k < numIndices; ++k)
|
||||
{
|
||||
mOutput << "#" << lineStart+k << "=LINE('',#" << pidArray[k] << ",#" << vectorStart+k << ")" << endstr;
|
||||
}
|
||||
|
||||
int directionStart = vectorStart + numIndices;
|
||||
for (int k=0; k < numIndices; ++k)
|
||||
{
|
||||
mOutput << "#" << vectorStart+k << "=VECTOR('',#" << directionStart+k << ",1.0)" << endstr;
|
||||
}
|
||||
|
||||
for (int k=0; k < numIndices; ++k)
|
||||
{
|
||||
const aiVector3D &dv = dvArray[k];
|
||||
mOutput << "#" << directionStart + k << "=DIRECTION('',(" << dv.x << "," << dv.y << "," << dv.z << "))" << endstr;
|
||||
}
|
||||
ind += 15 + 5*numIndices; // increase counter
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -667,9 +667,7 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
|
|||
|
||||
// convert to lower case for easier comparison
|
||||
for ( unsigned int c = 0; c < sz.length(); ++c ) {
|
||||
if ( isalpha( (unsigned char) sz[ c ] ) ) {
|
||||
sz[ c ] = (char) tolower( (unsigned char) sz[ c ] );
|
||||
}
|
||||
sz[ c ] = (char) tolower( (unsigned char) sz[ c ] );
|
||||
}
|
||||
|
||||
// Place texture filename property under the corresponding name
|
||||
|
|
|
|||
|
|
@ -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") {
|
||||
|
|
|
|||
|
|
@ -196,7 +196,7 @@ inline std::string getCurrentAssetDir(const std::string &pFile) {
|
|||
std::string path = pFile;
|
||||
int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\')));
|
||||
if (pos == int(std::string::npos)) {
|
||||
return "";
|
||||
return std::string();
|
||||
}
|
||||
|
||||
return pFile.substr(0, pos + 1);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -99,8 +99,8 @@ public:
|
|||
virtual ~Logger();
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
/** @brief Writes a info message
|
||||
* @param message Info message*/
|
||||
/** @brief Writes a debug message
|
||||
* @param message Debug message*/
|
||||
void debug(const char* message);
|
||||
|
||||
template<typename... T>
|
||||
|
|
@ -109,10 +109,10 @@ public:
|
|||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
/** @brief Writes a debug message
|
||||
/** @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());
|
||||
|
|
@ -140,7 +140,7 @@ public:
|
|||
|
||||
// ----------------------------------------------------------------------
|
||||
/** @brief Writes an error message
|
||||
* @param message Info message*/
|
||||
* @param message Error message*/
|
||||
void error(const char* message);
|
||||
|
||||
template<typename... T>
|
||||
|
|
|
|||
|
|
@ -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). */
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue