From 058f98a63658dc1a2579826ba167fd61bed1e21f Mon Sep 17 00:00:00 2001 From: sanine Date: Fri, 4 Mar 2022 10:47:15 -0600 Subject: add assimp submodule --- .../assimp-master/code/AssetLib/Step/STEPFile.h | 971 +++++++++++++++++++++ 1 file changed, 971 insertions(+) create mode 100644 src/mesh/assimp-master/code/AssetLib/Step/STEPFile.h (limited to 'src/mesh/assimp-master/code/AssetLib/Step/STEPFile.h') diff --git a/src/mesh/assimp-master/code/AssetLib/Step/STEPFile.h b/src/mesh/assimp-master/code/AssetLib/Step/STEPFile.h new file mode 100644 index 0000000..e09faad --- /dev/null +++ b/src/mesh/assimp-master/code/AssetLib/Step/STEPFile.h @@ -0,0 +1,971 @@ +/* +Open Asset Import Library (assimp) +---------------------------------------------------------------------- + +Copyright (c) 2006-2020, assimp team + + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the +following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------------------------------------- +*/ + +#ifndef INCLUDED_AI_STEPFILE_H +#define INCLUDED_AI_STEPFILE_H + +#include +#include +#include +#include +#include +#include + +#include "AssetLib/FBX/FBXDocument.h" //ObjectMap::value_type + +#include + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable : 4127 4456 4245 4512 ) +#endif // _MSC_VER + +// +#if _MSC_VER > 1500 || (defined __GNUC___) +# define ASSIMP_STEP_USE_UNORDERED_MULTIMAP +#else +# define step_unordered_map map +# define step_unordered_multimap multimap +#endif + +#ifdef ASSIMP_STEP_USE_UNORDERED_MULTIMAP +# include +# if defined(_MSC_VER) && _MSC_VER <= 1600 +# define step_unordered_map tr1::unordered_map +# define step_unordered_multimap tr1::unordered_multimap +# else +# define step_unordered_map unordered_map +# define step_unordered_multimap unordered_multimap +# endif +#endif + +#include + +// uncomment this to have the loader evaluate all entities upon loading. +// this is intended as stress test - by default, entities are evaluated +// lazily and therefore not unless needed. + +//#define ASSIMP_IFC_TEST + +namespace Assimp { + +// ******************************************************************************** +// before things get complicated, this is the basic outline: + +namespace STEP { + +namespace EXPRESS { + +// base data types known by EXPRESS schemata - any custom data types will derive one of those +class DataType; +class UNSET; /*: public DataType */ +class ISDERIVED; /*: public DataType */ +// class REAL; /*: public DataType */ +class ENUM; /*: public DataType */ +// class STRING; /*: public DataType */ +// class INTEGER; /*: public DataType */ +class ENTITY; /*: public DataType */ +class LIST; /*: public DataType */ +// class SELECT; /*: public DataType */ + +// a conversion schema is not exactly an EXPRESS schema, rather it +// is a list of pointers to conversion functions to build up the +// object tree from an input file. +class ConversionSchema; +} // namespace EXPRESS + +struct HeaderInfo; +class Object; +class LazyObject; +class DB; + +typedef Object *(*ConvertObjectProc)(const DB &db, const EXPRESS::LIST ¶ms); +} // namespace STEP + +// ******************************************************************************** + +namespace STEP { + +// ------------------------------------------------------------------------------- +/** Exception class used by the STEP loading & parsing code. It is typically + * coupled with a line number. */ +// ------------------------------------------------------------------------------- +struct SyntaxError : DeadlyImportError { + enum : uint64_t { + LINE_NOT_SPECIFIED = 0xfffffffffffffffLL + }; + + SyntaxError(const std::string &s, uint64_t line = LINE_NOT_SPECIFIED); +}; + +// ------------------------------------------------------------------------------- +/** Exception class used by the STEP loading & parsing code when a type + * error (i.e. an entity expects a string but receives a bool) occurs. + * It is typically coupled with both an entity id and a line number.*/ +// ------------------------------------------------------------------------------- +struct TypeError : DeadlyImportError { + enum : uint64_t { + ENTITY_NOT_SPECIFIED = 0xffffffffffffffffUL, + ENTITY_NOT_SPECIFIED_32 = 0x00000000ffffffff + }; + + TypeError(const std::string &s, uint64_t entity = ENTITY_NOT_SPECIFIED, uint64_t line = SyntaxError::LINE_NOT_SPECIFIED); +}; + +// hack to make a given member template-dependent +template +T2 &Couple(T2 &in) { + return in; +} + +namespace EXPRESS { + +// ------------------------------------------------------------------------------- +//** Base class for all STEP data types */ +// ------------------------------------------------------------------------------- +class DataType { +public: + typedef std::shared_ptr Out; + +public: + virtual ~DataType() { + } + +public: + template + const T &To() const { + return dynamic_cast(*this); + } + + template + T &To() { + return dynamic_cast(*this); + } + + template + const T *ToPtr() const { + return dynamic_cast(this); + } + + template + T *ToPtr() { + return dynamic_cast(this); + } + + // utilities to deal with SELECT entities, which currently lack automatic + // conversion support. + template + const T &ResolveSelect(const DB &db) const { + return Couple(db).MustGetObject(To())->template To(); + } + + template + const T *ResolveSelectPtr(const DB &db) const { + const EXPRESS::ENTITY *e = ToPtr(); + return e ? Couple(db).MustGetObject(*e)->template ToPtr() : (const T *)0; + } + +public: + /** parse a variable from a string and set 'inout' to the character + * behind the last consumed character. An optional schema enables, + * if specified, automatic conversion of custom data types. + * + * @throw SyntaxError + */ + static std::shared_ptr Parse(const char *&inout, + uint64_t line = SyntaxError::LINE_NOT_SPECIFIED, + const EXPRESS::ConversionSchema *schema = NULL); + +public: +}; + +typedef DataType SELECT; +typedef DataType LOGICAL; + +// ------------------------------------------------------------------------------- +/** Sentinel class to represent explicitly unset (optional) fields ($) */ +// ------------------------------------------------------------------------------- +class UNSET : public DataType { +public: +private: +}; + +// ------------------------------------------------------------------------------- +/** Sentinel class to represent explicitly derived fields (*) */ +// ------------------------------------------------------------------------------- +class ISDERIVED : public DataType { +public: +private: +}; + +// ------------------------------------------------------------------------------- +/** Shared implementation for some of the primitive data type, i.e. int, float */ +// ------------------------------------------------------------------------------- +template +class PrimitiveDataType : public DataType { +public: + // This is the type that will cd ultimatively be used to + // expose this data type to the user. + typedef T Out; + + PrimitiveDataType() {} + PrimitiveDataType(const T &val) : + val(val) {} + + PrimitiveDataType(const PrimitiveDataType &o) { + (*this) = o; + } + + operator const T &() const { + return val; + } + + PrimitiveDataType &operator=(const PrimitiveDataType &o) { + val = o.val; + return *this; + } + +protected: + T val; +}; + +typedef PrimitiveDataType INTEGER; +typedef PrimitiveDataType REAL; +typedef PrimitiveDataType NUMBER; +typedef PrimitiveDataType STRING; + +// ------------------------------------------------------------------------------- +/** Generic base class for all enumerated types */ +// ------------------------------------------------------------------------------- +class ENUMERATION : public STRING { +public: + ENUMERATION(const std::string &val) : + STRING(val) {} + +private: +}; + +typedef ENUMERATION BOOLEAN; + +// ------------------------------------------------------------------------------- +/** This is just a reference to an entity/object somewhere else */ +// ------------------------------------------------------------------------------- +class ENTITY : public PrimitiveDataType { +public: + ENTITY(uint64_t val) : + PrimitiveDataType(val) { + ai_assert(val != 0); + } + + ENTITY() : + PrimitiveDataType(TypeError::ENTITY_NOT_SPECIFIED) { + // empty + } + +private: +}; + +// ------------------------------------------------------------------------------- +/** Wrap any STEP aggregate: LIST, SET, ... */ +// ------------------------------------------------------------------------------- +class LIST : public DataType { +public: + // access a particular list index, throw std::range_error for wrong indices + std::shared_ptr operator[](size_t index) const { + return members[index]; + } + + size_t GetSize() const { + return members.size(); + } + +public: + /** @see DaraType::Parse */ + static std::shared_ptr Parse(const char *&inout, + uint64_t line = SyntaxError::LINE_NOT_SPECIFIED, + const EXPRESS::ConversionSchema *schema = NULL); + +private: + typedef std::vector> MemberList; + MemberList members; +}; + +class BINARY : public PrimitiveDataType { +public: + BINARY(uint32_t val) : + PrimitiveDataType(val) { + // empty + } + + BINARY() : + PrimitiveDataType(TypeError::ENTITY_NOT_SPECIFIED_32) { + // empty + } +}; + +// ------------------------------------------------------------------------------- +/* Not exactly a full EXPRESS schema but rather a list of conversion functions + * to extract valid C++ objects out of a STEP file. Those conversion functions + * may, however, perform further schema validations. */ +// ------------------------------------------------------------------------------- +class ConversionSchema { +public: + struct SchemaEntry { + SchemaEntry(const char *name, ConvertObjectProc func) : + mName(name), mFunc(func) { + // empty + } + + const char *mName; + ConvertObjectProc mFunc; + }; + + typedef std::map ConverterMap; + + template + explicit ConversionSchema(const SchemaEntry (&schemas)[N]) { + *this = schemas; + } + + ConversionSchema() { + } + + ConvertObjectProc GetConverterProc(const std::string &name) const { + ConverterMap::const_iterator it = converters.find(name); + return it == converters.end() ? nullptr : (*it).second; + } + + bool IsKnownToken(const std::string &name) const { + return converters.find(name) != converters.end(); + } + + const char *GetStaticStringForToken(const std::string &token) const { + ConverterMap::const_iterator it = converters.find(token); + return it == converters.end() ? nullptr : (*it).first.c_str(); + } + + template + const ConversionSchema &operator=(const SchemaEntry (&schemas)[N]) { + for (size_t i = 0; i < N; ++i) { + const SchemaEntry &schema = schemas[i]; + converters[schema.mName] = schema.mFunc; + } + return *this; + } + +private: + ConverterMap converters; +}; +} // namespace EXPRESS + +// ------------------------------------------------------------------------------ +/** Bundle all the relevant info from a STEP header, parts of which may later + * be plainly dumped to the logfile, whereas others may help the caller pick an + * appropriate loading strategy.*/ +// ------------------------------------------------------------------------------ +struct HeaderInfo { + std::string timestamp; + std::string app; + std::string fileSchema; +}; + +// ------------------------------------------------------------------------------ +/** Base class for all concrete object instances */ +// ------------------------------------------------------------------------------ +class Object { +public: + Object(const char *classname = "unknown") : + id(0), classname(classname) { + // empty + } + + virtual ~Object() { + // empty + } + + // utilities to simplify casting to concrete types + template + const T &To() const { + return dynamic_cast(*this); + } + + template + T &To() { + return dynamic_cast(*this); + } + + template + const T *ToPtr() const { + return dynamic_cast(this); + } + + template + T *ToPtr() { + return dynamic_cast(this); + } + + uint64_t GetID() const { + return id; + } + + std::string GetClassName() const { + return classname; + } + + void SetID(uint64_t newval) { + id = newval; + } + +private: + uint64_t id; + const char *const classname; +}; + +template +size_t GenericFill(const STEP::DB &db, const EXPRESS::LIST ¶ms, T *in); +// (intentionally undefined) + +// ------------------------------------------------------------------------------ +/** CRTP shared base class for use by concrete entity implementation classes */ +// ------------------------------------------------------------------------------ +template +struct ObjectHelper : virtual Object { + ObjectHelper() : + aux_is_derived(0) { + // empty + } + + static Object *Construct(const STEP::DB &db, const EXPRESS::LIST ¶ms) { + // make sure we don't leak if Fill() throws an exception + std::unique_ptr impl(new TDerived()); + + // GenericFill is undefined so we need to have a specialization + const size_t num_args = GenericFill(db, params, &*impl); + (void)num_args; + + // the following check is commented because it will always trigger if + // parts of the entities are generated with dummy wrapper code. + // This is currently done to reduce the size of the loader + // code. + //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { + // DefaultLogger::get()->debug("STEP: not all parameters consumed"); + //} + return impl.release(); + } + + // note that this member always exists multiple times within the hierarchy + // of an individual object, so any access to it must be disambiguated. + std::bitset aux_is_derived; +}; + +// ------------------------------------------------------------------------------ +/** Class template used to represent OPTIONAL data members in the converted schema */ +// ------------------------------------------------------------------------------ +template +struct Maybe { + Maybe() : + have() { + // empty + } + + explicit Maybe(const T &ptr) : + ptr(ptr), have(true) { + // empty + } + + void flag_invalid() { + have = false; + } + + void flag_valid() { + have = true; + } + + bool operator!() const { + return !have; + } + + operator bool() const { + return have; + } + + operator const T &() const { + return Get(); + } + + const T &Get() const { + ai_assert(have); + return ptr; + } + + Maybe &operator=(const T &_ptr) { + ptr = _ptr; + have = true; + return *this; + } + +private: + template + friend struct InternGenericConvert; + + operator T &() { + return ptr; + } + + T ptr; + bool have; +}; + +// ------------------------------------------------------------------------------ +/** A LazyObject is created when needed. Before this happens, we just keep + the text line that contains the object definition. */ +// ------------------------------------------------------------------------------- +class LazyObject { + friend class DB; + +public: + LazyObject(DB &db, uint64_t id, uint64_t line, const char *type, const char *args); + ~LazyObject(); + + Object &operator*() { + if (!obj) { + LazyInit(); + ai_assert(obj); + } + return *obj; + } + + const Object &operator*() const { + if (!obj) { + LazyInit(); + ai_assert(obj); + } + return *obj; + } + + template + const T &To() const { + return dynamic_cast(**this); + } + + template + T &To() { + return dynamic_cast(**this); + } + + template + const T *ToPtr() const { + return dynamic_cast(&**this); + } + + template + T *ToPtr() { + return dynamic_cast(&**this); + } + + Object *operator->() { + return &**this; + } + + const Object *operator->() const { + return &**this; + } + + bool operator==(const std::string &atype) const { + return type == atype; + } + + bool operator!=(const std::string &atype) const { + return type != atype; + } + + uint64_t GetID() const { + return id; + } + +private: + void LazyInit() const; + +private: + mutable uint64_t id; + const char *const type; + DB &db; + mutable const char *args; + mutable Object *obj; +}; + +template +inline bool operator==(const std::shared_ptr &lo, T whatever) { + return *lo == whatever; // XXX use std::forward if we have 0x +} + +template +inline bool operator==(const std::pair> &lo, T whatever) { + return *(lo.second) == whatever; // XXX use std::forward if we have 0x +} + +// ------------------------------------------------------------------------------ +/** Class template used to represent lazily evaluated object references in the converted schema */ +// ------------------------------------------------------------------------------ +template +struct Lazy { + typedef Lazy Out; + Lazy(const LazyObject *obj = nullptr) : + obj(obj) { + // empty + } + + operator const T *() const { + return obj->ToPtr(); + } + + operator const T &() const { + return obj->To(); + } + + const T &operator*() const { + return obj->To(); + } + + const T *operator->() const { + return &obj->To(); + } + + const LazyObject *obj; +}; + +// ------------------------------------------------------------------------------ +/** Class template used to represent LIST and SET data members in the converted schema */ +// ------------------------------------------------------------------------------ +template +struct ListOf : public std::vector { + typedef typename T::Out OutScalar; + typedef ListOf Out; + + ListOf() { + static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt"); + } +}; + +// ------------------------------------------------------------------------------ +template +struct PickBaseType { + typedef EXPRESS::PrimitiveDataType Type; +}; + +template +struct PickBaseType> { + typedef EXPRESS::ENTITY Type; +}; + +template <> +struct PickBaseType>; + +// ------------------------------------------------------------------------------ +template +struct InternGenericConvert { + void operator()(T &out, const std::shared_ptr &in, const STEP::DB & /*db*/) { + try { + out = dynamic_cast::Type &>(*in); + } catch (std::bad_cast &) { + throw TypeError("type error reading literal field"); + } + } +}; + +template <> +struct InternGenericConvert> { + void operator()(std::shared_ptr &out, const std::shared_ptr &in, const STEP::DB & /*db*/) { + out = in; + } +}; + +template +struct InternGenericConvert> { + void operator()(Maybe &out, const std::shared_ptr &in, const STEP::DB &db) { + GenericConvert((T &)out, in, db); + out.flag_valid(); + } +}; + +#if _MSC_VER > 1920 +#pragma warning(push) +#pragma warning(disable : 4127) +#endif // _WIN32 + +template +struct InternGenericConvertList { + void operator()(ListOf &out, const std::shared_ptr &inp_base, const STEP::DB &db) { + + const EXPRESS::LIST *inp = dynamic_cast(inp_base.get()); + if (!inp) { + throw TypeError("type error reading aggregate"); + } + + // XXX is this really how the EXPRESS notation ([?:3],[1:3]) is intended? + const size_t len = inp->GetSize(); + if (0 != max_cnt && len > max_cnt) { + ASSIMP_LOG_WARN("too many aggregate elements"); + } else if (len < min_cnt) { + ASSIMP_LOG_WARN("too few aggregate elements"); + } + + out.reserve(inp->GetSize()); + for (size_t i = 0; i < inp->GetSize(); ++i) { + + out.push_back(typename ListOf::OutScalar()); + try { + GenericConvert(out.back(), (*inp)[i], db); + } catch (const TypeError &t) { + throw TypeError(t.what() + std::string(" of aggregate")); + } + } + } +}; + +template +struct InternGenericConvert> { + void operator()(Lazy &out, const std::shared_ptr &in_base, const STEP::DB &db) { + const EXPRESS::ENTITY *in = dynamic_cast(in_base.get()); + if (!in) { + throw TypeError("type error reading entity"); + } + out = Couple(db).GetObject(*in); + } +}; + +template +inline void GenericConvert(T1 &a, const std::shared_ptr &b, const STEP::DB &db) { + return InternGenericConvert()(a, b, db); +} + +template +inline void GenericConvert(ListOf &a, const std::shared_ptr &b, const STEP::DB &db) { + return InternGenericConvertList()(a, b, db); +} + +// ------------------------------------------------------------------------------ +/** Lightweight manager class that holds the map of all objects in a + * STEP file. DB's are exclusively maintained by the functions in + * STEPFileReader.h*/ +// ------------------------------------------------------------------------------- +class DB { + friend DB *ReadFileHeader(std::shared_ptr stream); + friend void ReadFile(DB &db, const EXPRESS::ConversionSchema &scheme, + const char *const *types_to_track, size_t len, + const char *const *inverse_indices_to_track, size_t len2); + + friend class LazyObject; + +public: + // objects indexed by ID - this can grow pretty large (i.e some hundred million + // entries), so use raw pointers to avoid *any* overhead. + typedef std::map ObjectMap; + + // objects indexed by their declarative type, but only for those that we truly want + typedef std::set ObjectSet; + typedef std::map ObjectMapByType; + + // list of types for which to keep inverse indices for all references + // that the respective objects keep. + // the list keeps pointers to strings in static storage + typedef std::set InverseWhitelist; + + // references - for each object id the ids of all objects which reference it + // this is used to simulate STEP inverse indices for selected types. + typedef std::step_unordered_multimap RefMap; + typedef std::pair RefMapRange; + +private: + DB(const std::shared_ptr &reader) : + reader(reader), splitter(*reader, true, true), evaluated_count(), schema(nullptr) {} + +public: + ~DB() { + for (ObjectMap::value_type &o : objects) { + delete o.second; + } + } + + uint64_t GetObjectCount() const { + return objects.size(); + } + + uint64_t GetEvaluatedObjectCount() const { + return evaluated_count; + } + + const HeaderInfo &GetHeader() const { + return header; + } + + const EXPRESS::ConversionSchema &GetSchema() const { + return *schema; + } + + const ObjectMap &GetObjects() const { + return objects; + } + + const ObjectMapByType &GetObjectsByType() const { + return objects_bytype; + } + + const RefMap &GetRefs() const { + return refs; + } + + bool KeepInverseIndicesForType(const char *const type) const { + return inv_whitelist.find(type) != inv_whitelist.end(); + } + + // get the yet unevaluated object record with a given id + const LazyObject *GetObject(uint64_t id) const { + const ObjectMap::const_iterator it = objects.find(id); + if (it != objects.end()) { + return (*it).second; + } + return nullptr; + } + + // get an arbitrary object out of the soup with the only restriction being its type. + const LazyObject *GetObject(const std::string &type) const { + const ObjectMapByType::const_iterator it = objects_bytype.find(type); + if (it != objects_bytype.end() && (*it).second.size()) { + return *(*it).second.begin(); + } + return NULL; + } + + // same, but raise an exception if the object doesn't exist and return a reference + const LazyObject &MustGetObject(uint64_t id) const { + const LazyObject *o = GetObject(id); + if (!o) { + throw TypeError("requested entity is not present", id); + } + return *o; + } + + const LazyObject &MustGetObject(const std::string &type) const { + const LazyObject *o = GetObject(type); + if (!o) { + throw TypeError("requested entity of type " + type + "is not present"); + } + return *o; + } + +#ifdef ASSIMP_IFC_TEST + + // evaluate *all* entities in the file. this is a power test for the loader + void EvaluateAll() { + for (ObjectMap::value_type &e : objects) { + **e.second; + } + ai_assert(evaluated_count == objects.size()); + } + +#endif + +private: + // full access only offered to close friends - they should + // use the provided getters rather than messing around with + // the members directly. + LineSplitter &GetSplitter() { + return splitter; + } + + void InternInsert(const LazyObject *lz) { + objects[lz->GetID()] = lz; + + const ObjectMapByType::iterator it = objects_bytype.find(lz->type); + if (it != objects_bytype.end()) { + (*it).second.insert(lz); + } + } + + void SetSchema(const EXPRESS::ConversionSchema &_schema) { + schema = &_schema; + } + + void SetTypesToTrack(const char *const *types, size_t N) { + for (size_t i = 0; i < N; ++i) { + objects_bytype[types[i]] = ObjectSet(); + } + } + + void SetInverseIndicesToTrack(const char *const *types, size_t N) { + for (size_t i = 0; i < N; ++i) { + const char *const sz = schema->GetStaticStringForToken(types[i]); + ai_assert(sz); + inv_whitelist.insert(sz); + } + } + + HeaderInfo &GetHeader() { + return header; + } + + void MarkRef(uint64_t who, uint64_t by_whom) { + refs.insert(std::make_pair(who, by_whom)); + } + +private: + HeaderInfo header; + ObjectMap objects; + ObjectMapByType objects_bytype; + RefMap refs; + InverseWhitelist inv_whitelist; + std::shared_ptr reader; + LineSplitter splitter; + uint64_t evaluated_count; + const EXPRESS::ConversionSchema *schema; +}; + +#ifdef _MSC_VER +#pragma warning(pop) +#endif // _MSC_VER + +} // namespace STEP + +} // namespace Assimp + +#endif // INCLUDED_AI_STEPFILE_H -- cgit v1.2.1