summaryrefslogtreecommitdiff
path: root/libs/assimp/code/AssetLib/Step
diff options
context:
space:
mode:
authorsanine <sanine.not@pm.me>2023-02-12 23:53:22 -0600
committersanine <sanine.not@pm.me>2023-02-12 23:53:22 -0600
commitf1fe73d1909a2448a004a88362a1a532d0d4f7c3 (patch)
treeab37ae3837e2f858de2932bcee9f26e69fab3db1 /libs/assimp/code/AssetLib/Step
parentf567ea1e2798fd3156a416e61f083ea3e6b95719 (diff)
switch to tinyobj and nanovg from assimp and cairo
Diffstat (limited to 'libs/assimp/code/AssetLib/Step')
-rw-r--r--libs/assimp/code/AssetLib/Step/STEPFile.h971
-rw-r--r--libs/assimp/code/AssetLib/Step/StepExporter.cpp411
-rw-r--r--libs/assimp/code/AssetLib/Step/StepExporter.h111
3 files changed, 0 insertions, 1493 deletions
diff --git a/libs/assimp/code/AssetLib/Step/STEPFile.h b/libs/assimp/code/AssetLib/Step/STEPFile.h
deleted file mode 100644
index e09faad..0000000
--- a/libs/assimp/code/AssetLib/Step/STEPFile.h
+++ /dev/null
@@ -1,971 +0,0 @@
-/*
-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 <bitset>
-#include <map>
-#include <memory>
-#include <set>
-#include <typeinfo>
-#include <vector>
-
-#include "AssetLib/FBX/FBXDocument.h" //ObjectMap::value_type
-
-#include <assimp/DefaultLogger.hpp>
-
-#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 <unordered_map>
-# 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 <assimp/LineSplitter.h>
-
-// 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 &params);
-} // 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 <typename T, typename T2>
-T2 &Couple(T2 &in) {
- return in;
-}
-
-namespace EXPRESS {
-
-// -------------------------------------------------------------------------------
-//** Base class for all STEP data types */
-// -------------------------------------------------------------------------------
-class DataType {
-public:
- typedef std::shared_ptr<const DataType> Out;
-
-public:
- virtual ~DataType() {
- }
-
-public:
- template <typename T>
- const T &To() const {
- return dynamic_cast<const T &>(*this);
- }
-
- template <typename T>
- T &To() {
- return dynamic_cast<T &>(*this);
- }
-
- template <typename T>
- const T *ToPtr() const {
- return dynamic_cast<const T *>(this);
- }
-
- template <typename T>
- T *ToPtr() {
- return dynamic_cast<T *>(this);
- }
-
- // utilities to deal with SELECT entities, which currently lack automatic
- // conversion support.
- template <typename T>
- const T &ResolveSelect(const DB &db) const {
- return Couple<T>(db).MustGetObject(To<EXPRESS::ENTITY>())->template To<T>();
- }
-
- template <typename T>
- const T *ResolveSelectPtr(const DB &db) const {
- const EXPRESS::ENTITY *e = ToPtr<EXPRESS::ENTITY>();
- return e ? Couple<T>(db).MustGetObject(*e)->template ToPtr<T>() : (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<const EXPRESS::DataType> 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 <typename T>
-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<int64_t> INTEGER;
-typedef PrimitiveDataType<double> REAL;
-typedef PrimitiveDataType<double> NUMBER;
-typedef PrimitiveDataType<std::string> 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<uint64_t> {
-public:
- ENTITY(uint64_t val) :
- PrimitiveDataType<uint64_t>(val) {
- ai_assert(val != 0);
- }
-
- ENTITY() :
- PrimitiveDataType<uint64_t>(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<const DataType> operator[](size_t index) const {
- return members[index];
- }
-
- size_t GetSize() const {
- return members.size();
- }
-
-public:
- /** @see DaraType::Parse */
- static std::shared_ptr<const EXPRESS::LIST> Parse(const char *&inout,
- uint64_t line = SyntaxError::LINE_NOT_SPECIFIED,
- const EXPRESS::ConversionSchema *schema = NULL);
-
-private:
- typedef std::vector<std::shared_ptr<const DataType>> MemberList;
- MemberList members;
-};
-
-class BINARY : public PrimitiveDataType<uint32_t> {
-public:
- BINARY(uint32_t val) :
- PrimitiveDataType<uint32_t>(val) {
- // empty
- }
-
- BINARY() :
- PrimitiveDataType<uint32_t>(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<std::string, ConvertObjectProc> ConverterMap;
-
- template <size_t N>
- 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 <size_t N>
- 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 <typename T>
- const T &To() const {
- return dynamic_cast<const T &>(*this);
- }
-
- template <typename T>
- T &To() {
- return dynamic_cast<T &>(*this);
- }
-
- template <typename T>
- const T *ToPtr() const {
- return dynamic_cast<const T *>(this);
- }
-
- template <typename T>
- T *ToPtr() {
- return dynamic_cast<T *>(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 <typename T>
-size_t GenericFill(const STEP::DB &db, const EXPRESS::LIST &params, T *in);
-// (intentionally undefined)
-
-// ------------------------------------------------------------------------------
-/** CRTP shared base class for use by concrete entity implementation classes */
-// ------------------------------------------------------------------------------
-template <typename TDerived, size_t arg_count>
-struct ObjectHelper : virtual Object {
- ObjectHelper() :
- aux_is_derived(0) {
- // empty
- }
-
- static Object *Construct(const STEP::DB &db, const EXPRESS::LIST &params) {
- // make sure we don't leak if Fill() throws an exception
- std::unique_ptr<TDerived> impl(new TDerived());
-
- // GenericFill<T> is undefined so we need to have a specialization
- const size_t num_args = GenericFill<TDerived>(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<arg_count> aux_is_derived;
-};
-
-// ------------------------------------------------------------------------------
-/** Class template used to represent OPTIONAL data members in the converted schema */
-// ------------------------------------------------------------------------------
-template <typename T>
-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 <typename T2>
- 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 <typename T>
- const T &To() const {
- return dynamic_cast<const T &>(**this);
- }
-
- template <typename T>
- T &To() {
- return dynamic_cast<T &>(**this);
- }
-
- template <typename T>
- const T *ToPtr() const {
- return dynamic_cast<const T *>(&**this);
- }
-
- template <typename T>
- T *ToPtr() {
- return dynamic_cast<T *>(&**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 <typename T>
-inline bool operator==(const std::shared_ptr<LazyObject> &lo, T whatever) {
- return *lo == whatever; // XXX use std::forward if we have 0x
-}
-
-template <typename T>
-inline bool operator==(const std::pair<uint64_t, std::shared_ptr<LazyObject>> &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 <typename T>
-struct Lazy {
- typedef Lazy Out;
- Lazy(const LazyObject *obj = nullptr) :
- obj(obj) {
- // empty
- }
-
- operator const T *() const {
- return obj->ToPtr<T>();
- }
-
- operator const T &() const {
- return obj->To<T>();
- }
-
- const T &operator*() const {
- return obj->To<T>();
- }
-
- const T *operator->() const {
- return &obj->To<T>();
- }
-
- const LazyObject *obj;
-};
-
-// ------------------------------------------------------------------------------
-/** Class template used to represent LIST and SET data members in the converted schema */
-// ------------------------------------------------------------------------------
-template <typename T, uint64_t min_cnt, uint64_t max_cnt = 0uL>
-struct ListOf : public std::vector<typename T::Out> {
- typedef typename T::Out OutScalar;
- typedef ListOf Out;
-
- ListOf() {
- static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt");
- }
-};
-
-// ------------------------------------------------------------------------------
-template <typename TOut>
-struct PickBaseType {
- typedef EXPRESS::PrimitiveDataType<TOut> Type;
-};
-
-template <typename TOut>
-struct PickBaseType<Lazy<TOut>> {
- typedef EXPRESS::ENTITY Type;
-};
-
-template <>
-struct PickBaseType<std::shared_ptr<const EXPRESS::DataType>>;
-
-// ------------------------------------------------------------------------------
-template <typename T>
-struct InternGenericConvert {
- void operator()(T &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB & /*db*/) {
- try {
- out = dynamic_cast<const typename PickBaseType<T>::Type &>(*in);
- } catch (std::bad_cast &) {
- throw TypeError("type error reading literal field");
- }
- }
-};
-
-template <>
-struct InternGenericConvert<std::shared_ptr<const EXPRESS::DataType>> {
- void operator()(std::shared_ptr<const EXPRESS::DataType> &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB & /*db*/) {
- out = in;
- }
-};
-
-template <typename T>
-struct InternGenericConvert<Maybe<T>> {
- void operator()(Maybe<T> &out, const std::shared_ptr<const EXPRESS::DataType> &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 <typename T, uint64_t min_cnt, uint64_t max_cnt>
-struct InternGenericConvertList {
- void operator()(ListOf<T, min_cnt, max_cnt> &out, const std::shared_ptr<const EXPRESS::DataType> &inp_base, const STEP::DB &db) {
-
- const EXPRESS::LIST *inp = dynamic_cast<const EXPRESS::LIST *>(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<T, min_cnt, max_cnt>::OutScalar());
- try {
- GenericConvert(out.back(), (*inp)[i], db);
- } catch (const TypeError &t) {
- throw TypeError(t.what() + std::string(" of aggregate"));
- }
- }
- }
-};
-
-template <typename T>
-struct InternGenericConvert<Lazy<T>> {
- void operator()(Lazy<T> &out, const std::shared_ptr<const EXPRESS::DataType> &in_base, const STEP::DB &db) {
- const EXPRESS::ENTITY *in = dynamic_cast<const EXPRESS::ENTITY *>(in_base.get());
- if (!in) {
- throw TypeError("type error reading entity");
- }
- out = Couple<T>(db).GetObject(*in);
- }
-};
-
-template <typename T1>
-inline void GenericConvert(T1 &a, const std::shared_ptr<const EXPRESS::DataType> &b, const STEP::DB &db) {
- return InternGenericConvert<T1>()(a, b, db);
-}
-
-template <typename T1, uint64_t N1, uint64_t N2>
-inline void GenericConvert(ListOf<T1, N1, N2> &a, const std::shared_ptr<const EXPRESS::DataType> &b, const STEP::DB &db) {
- return InternGenericConvertList<T1, N1, N2>()(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<IOStream> 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<uint64_t, const LazyObject *> ObjectMap;
-
- // objects indexed by their declarative type, but only for those that we truly want
- typedef std::set<const LazyObject *> ObjectSet;
- typedef std::map<std::string, ObjectSet> 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<const char *> 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<uint64_t, uint64_t> RefMap;
- typedef std::pair<RefMap::const_iterator, RefMap::const_iterator> RefMapRange;
-
-private:
- DB(const std::shared_ptr<StreamReaderLE> &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<StreamReaderLE> 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
diff --git a/libs/assimp/code/AssetLib/Step/StepExporter.cpp b/libs/assimp/code/AssetLib/Step/StepExporter.cpp
deleted file mode 100644
index e13c9ed..0000000
--- a/libs/assimp/code/AssetLib/Step/StepExporter.cpp
+++ /dev/null
@@ -1,411 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, 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.
-
-@author: Richard Steffen, 2015
-----------------------------------------------------------------------
-*/
-
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
-
-#include "AssetLib/Step/StepExporter.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/Bitmap.h>
-#include <assimp/BaseImporter.h>
-#include <assimp/fast_atof.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/Exceptional.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
-#include <assimp/light.h>
-
-#include <iostream>
-#include <ctime>
-#include <set>
-#include <map>
-#include <list>
-#include <memory>
-
-//
-#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 <unordered_map>
-# 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
-
-typedef std::step_unordered_map<aiVector3D*, int> VectorIndexUMap;
-
-/* Tested with Step viewer v4 from www.ida-step.net */
-
-using namespace Assimp;
-
-namespace Assimp
-{
-
-// ------------------------------------------------------------------------------------------------
-// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
-void ExportSceneStep(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
-{
- std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
- std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
-
- // create/copy Properties
- ExportProperties props(*pProperties);
-
- // invoke the exporter
- StepExporter iDoTheExportThing( pScene, pIOSystem, path, file, &props);
-
- // 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) {
- throw DeadlyExportError("could not open output .stp file: " + std::string(pFile));
- }
-
- // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
- outfile->Write( iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()),1);
-}
-
-} // end of namespace Assimp
-
-
-namespace {
- // Collect world transformations for each node
- void CollectTrafos(const aiNode* node, std::map<const aiNode*, aiMatrix4x4>& trafos) {
- const aiMatrix4x4& parent = node->mParent ? trafos[node->mParent] : aiMatrix4x4();
- trafos[node] = parent * node->mTransformation;
- for (unsigned int i = 0; i < node->mNumChildren; ++i) {
- CollectTrafos(node->mChildren[i], trafos);
- }
- }
-
- // Generate a flat list of the meshes (by index) assigned to each node
- void CollectMeshes(const aiNode* node, std::multimap<const aiNode*, unsigned int>& meshes) {
- for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
- meshes.insert(std::make_pair(node, node->mMeshes[i]));
- }
- for (unsigned int i = 0; i < node->mNumChildren; ++i) {
- CollectMeshes(node->mChildren[i], meshes);
- }
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructor for a specific scene to export
-StepExporter::StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path,
- const std::string& file, const ExportProperties* pProperties) :
- mProperties(pProperties), mIOSystem(pIOSystem), mFile(file), mPath(path),
- mScene(pScene), endstr(";\n") {
- CollectTrafos(pScene->mRootNode, trafos);
- CollectMeshes(pScene->mRootNode, meshes);
-
- // make sure that all formatting happens using the standard, C locale and not the user's current locale
- mOutput.imbue(std::locale("C"));
- mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
-
- // start writing
- WriteFile();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Starts writing the contents
-void StepExporter::WriteFile()
-{
- // see http://shodhganga.inflibnet.ac.in:8080/jspui/bitstream/10603/14116/11/11_chapter%203.pdf
- // note, that all realnumber values must be comma separated in x files
- mOutput.setf(std::ios::fixed);
- // precision for double
- // see http://stackoverflow.com/questions/554063/how-do-i-print-a-double-value-with-full-precision-using-cout
- mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
-
- // standard color
- aiColor4D fColor;
- fColor.r = 0.8f;
- fColor.g = 0.8f;
- fColor.b = 0.8f;
-
- int ind = 100; // the start index to be used
- 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;
-
- for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
- {
- aiMesh* mesh = mScene->mMeshes[i];
- for (unsigned int j=0; j<mesh->mNumFaces; ++j)
- {
- aiFace* face = &(mesh->mFaces[j]);
-
- if (face->mNumIndices >= 3) faceEntryLen.push_back(15 + 5 * face->mNumIndices);
- }
- for (unsigned int j=0; j<mesh->mNumVertices; ++j)
- {
- aiVector3D* v = &(mesh->mVertices[j]);
- it =uniqueVerts.find(v);
- if (it == uniqueVerts.end())
- {
- uniqueVerts[v] = -1; // first mark the vector as not transformed
- }
- }
- }
-
- static const unsigned int date_nb_chars = 20;
- char date_str[date_nb_chars];
- std::time_t date = std::time(nullptr);
- std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
-
- // write the header
- mOutput << "ISO-10303-21" << endstr;
- mOutput << "HEADER" << endstr;
- mOutput << "FILE_DESCRIPTION(('STEP AP214'),'1')" << endstr;
- mOutput << "FILE_NAME('" << mFile << ".stp','" << date_str << "',(' '),(' '),'Spatial InterOp 3D',' ',' ')" << endstr;
- mOutput << "FILE_SCHEMA(('automotive_design'))" << endstr;
- mOutput << "ENDSEC" << endstr;
-
- // write the top of data
- mOutput << "DATA" << endstr;
- mOutput << "#1=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(' ',(";
- size_t countFace = faceEntryLen.size();
- size_t faceLenIndex = ind + 2 * uniqueVerts.size();
- for (size_t i=0; i<countFace; ++i)
- {
- mOutput << "#" << faceLenIndex;
- if (i!=countFace-1) mOutput << ",";
- faceLenIndex += faceEntryLen[i];
- }
- mOutput << "),#6)" << endstr;
-
- mOutput << "#2=PRODUCT_DEFINITION_CONTEXT('',#7,'design')" << endstr;
- mOutput << "#3=APPLICATION_PROTOCOL_DEFINITION('INTERNATIONAL STANDARD','automotive_design',1994,#7)" << endstr;
- mOutput << "#4=PRODUCT_CATEGORY_RELATIONSHIP('NONE','NONE',#8,#9)" << endstr;
- mOutput << "#5=SHAPE_DEFINITION_REPRESENTATION(#10,#11)" << endstr;
- mOutput << "#6= (GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#12))GLOBAL_UNIT_ASSIGNED_CONTEXT((#13,#14,#15))REPRESENTATION_CONTEXT('NONE','WORKSPACE'))" << endstr;
- mOutput << "#7=APPLICATION_CONTEXT(' ')" << endstr;
- mOutput << "#8=PRODUCT_CATEGORY('part','NONE')" << endstr;
- mOutput << "#9=PRODUCT_RELATED_PRODUCT_CATEGORY('detail',' ',(#17))" << endstr;
- mOutput << "#10=PRODUCT_DEFINITION_SHAPE('NONE','NONE',#18)" << endstr;
- mOutput << "#11=MANIFOLD_SURFACE_SHAPE_REPRESENTATION('Root',(#16,#19),#6)" << endstr;
- mOutput << "#12=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.0E-006),#13,'','')" << endstr;
- mOutput << "#13=(CONVERSION_BASED_UNIT('METRE',#20)LENGTH_UNIT()NAMED_UNIT(#21))" << endstr;
- mOutput << "#14=(NAMED_UNIT(#22)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))" << endstr;
- mOutput << "#15=(NAMED_UNIT(#22)SOLID_ANGLE_UNIT()SI_UNIT($,.STERADIAN.))" << endstr;
- mOutput << "#16=SHELL_BASED_SURFACE_MODEL('Root',(#29))" << endstr;
- mOutput << "#17=PRODUCT('Root','Root','Root',(#23))" << endstr;
- mOutput << "#18=PRODUCT_DEFINITION('NONE','NONE',#24,#2)" << endstr;
- mOutput << "#19=AXIS2_PLACEMENT_3D('',#25,#26,#27)" << endstr;
- mOutput << "#20=LENGTH_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.0),#28)" << endstr;
- mOutput << "#21=DIMENSIONAL_EXPONENTS(1.0,0.0,0.0,0.0,0.0,0.0,0.0)" << endstr;
- mOutput << "#22=DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,0.0,0.0)" << endstr;
- mOutput << "#23=PRODUCT_CONTEXT('',#7,'mechanical')" << endstr;
- mOutput << "#24=PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE(' ','NONE',#17,.NOT_KNOWN.)" << endstr;
- mOutput << "#25=CARTESIAN_POINT('',(0.0,0.0,0.0))" << endstr;
- mOutput << "#26=DIRECTION('',(0.0,0.0,1.0))" << endstr;
- mOutput << "#27=DIRECTION('',(1.0,0.0,0.0))" << endstr;
- mOutput << "#28= (NAMED_UNIT(#21)LENGTH_UNIT()SI_UNIT(.MILLI.,.METRE.))" << endstr;
- mOutput << "#29=CLOSED_SHELL('',(";
- faceLenIndex = ind + 2 * uniqueVerts.size() + 8;
- for (size_t i=0; i<countFace; ++i)
- {
- mOutput << "#" << faceLenIndex;
- if (i!=countFace-1) mOutput << ",";
- faceLenIndex += faceEntryLen[i];
- }
- mOutput << "))" << endstr;
-
- // write all the unique transformed CARTESIAN and VERTEX
- for (MeshesByNodeMap::const_iterator it2 = meshes.begin(); it2 != meshes.end(); ++it2)
- {
- const aiNode& node = *(*it2).first;
- unsigned int mesh_idx = (*it2).second;
-
- const aiMesh* mesh = mScene->mMeshes[mesh_idx];
- aiMatrix4x4& trafo = trafos[&node];
- for (unsigned int i = 0; i < mesh->mNumVertices; ++i)
- {
- aiVector3D* v = &(mesh->mVertices[i]);
- it = uniqueVerts.find(v);
- if (it->second >=0 ) continue;
- it->second = ind; // this one is new, so set the index (ind)
- aiVector3D vt = trafo * (*v); // transform the coordinate
- mOutput << "#" << it->second << "=CARTESIAN_POINT('',(" << vt.x << "," << vt.y << "," << vt.z << "))" << endstr;
- mOutput << "#" << it->second+1 << "=VERTEX_POINT('',#" << it->second << ")" << endstr;
- ind += 2;
- }
- }
-
- // write the triangles
- for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
- {
- aiMesh* mesh = mScene->mMeshes[i];
- for (unsigned int j=0; j<mesh->mNumFaces; ++j)
- {
- aiFace* face = &(mesh->mFaces[j]);
-
- const int numIndices = face->mNumIndices;
- if (numIndices < 3) continue;
-
- 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 *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();
-
- // mean vertex color for the face if available
- if (mesh->HasVertexColors(0))
- {
- fColor.r = 0.0;
- fColor.g = 0.0;
- fColor.b = 0.0;
- fColor += mesh->mColors[0][face->mIndices[0]];
- fColor += mesh->mColors[0][face->mIndices[1]];
- fColor += mesh->mColors[0][face->mIndices[2]];
- fColor /= 3.0f;
- }
-
- int sid = ind; // the sub index
- mOutput << "#" << sid << "=STYLED_ITEM('',(#" << sid+1 << "),#" << sid+8 << ")" << endstr; /* the item that must be referenced in #1 */
- /* This is the color information of the Triangle */
- mOutput << "#" << sid+1 << "=PRESENTATION_STYLE_ASSIGNMENT((#" << sid+2 << "))" << endstr;
- mOutput << "#" << sid+2 << "=SURFACE_STYLE_USAGE(.BOTH.,#" << sid+3 << ")" << endstr;
- mOutput << "#" << sid+3 << "=SURFACE_SIDE_STYLE('',(#" << sid+4 << "))" << endstr;
- mOutput << "#" << sid+4 << "=SURFACE_STYLE_FILL_AREA(#" << sid+5 << ")" << endstr;
- mOutput << "#" << sid+5 << "=FILL_AREA_STYLE('',(#" << sid+6 << "))" << endstr;
- mOutput << "#" << sid+6 << "=FILL_AREA_STYLE_COLOUR('',#" << sid+7 << ")" << endstr;
- mOutput << "#" << sid+7 << "=COLOUR_RGB(''," << fColor.r << "," << fColor.g << "," << fColor.b << ")" << endstr;
-
- /* this is the geometry */
- mOutput << "#" << sid+8 << "=FACE_SURFACE('',(#" << sid+13 << "),#" << sid+9<< ",.T.)" << endstr; /* the face that must be referenced in 29 */
-
- /* 2 directions of the plane */
- mOutput << "#" << sid+9 << "=PLANE('',#" << sid+10 << ")" << 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('',(";
- int edgeLoopStart = sid + 15;
- for (int k = 0; k < numIndices; ++k)
- {
- if (k == 0)
- mOutput << "#";
- else
- mOutput << ",#";
- mOutput << edgeLoopStart + k;
- }
- mOutput << "))" << endstr;
-
- /* edge loop */
- int orientedEdgesStart = edgeLoopStart + numIndices;
- for (int k=0; k < numIndices; k++)
- {
- mOutput << "#" << edgeLoopStart+k << "=ORIENTED_EDGE('',*,*,#" << orientedEdgesStart + k << ",.T.)" << endstr;
- }
-
- /* oriented edges */
- 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;
- }
-
- /* 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
- }
- }
-
- mOutput << "ENDSEC" << endstr; // end of data section
- mOutput << "END-ISO-10303-21" << endstr; // end of file
-}
-
-#endif
-#endif
diff --git a/libs/assimp/code/AssetLib/Step/StepExporter.h b/libs/assimp/code/AssetLib/Step/StepExporter.h
deleted file mode 100644
index a022626..0000000
--- a/libs/assimp/code/AssetLib/Step/StepExporter.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, 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.
-
-@author: Richard Steffen, 2014
-
-----------------------------------------------------------------------
-*/
-
-/** @file StepExporter.h
- * Declares the exporter class to write a scene to a Collada file
- */
-#ifndef AI_STEPEXPORTER_H_INC
-#define AI_STEPEXPORTER_H_INC
-
-#include <assimp/ai_assert.h>
-#include <assimp/matrix4x4.h>
-#include <assimp/Exporter.hpp>
-#include <sstream>
-
-
-struct aiScene;
-struct aiNode;
-
-namespace Assimp
-{
-
-/// Helper class to export a given scene to a StepFile.
-/// Note: an StepFile uses a left hand system. Assimp used a right hand system (OpenGL), therefore we have to transform everything
-class StepExporter
-{
-public:
- /// Constructor for a specific scene to export
- StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file, const ExportProperties* pProperties);
-
-protected:
- /// Starts writing the contents
- void WriteFile();
-
-public:
-
- /// Stringstream to write all output into
- std::stringstream mOutput;
-
-protected:
-
- /// hold the properties pointer
- const ExportProperties* mProperties;
-
- /// The IOSystem for output
- IOSystem* mIOSystem;
-
- /// Name of the file (without extension) where the scene will be exported
- std::string mFile;
-
- /// Path of the directory where the scene will be exported
- std::string mPath;
-
- /// The scene to be written
- const aiScene* mScene;
-
- /// current line end string for simple stream insertion
- std::string endstr;
-
- /// accumultated transformations for nodes
- std::map<const aiNode*, aiMatrix4x4> trafos;
-
- /// map to all meshed of nodes
- typedef std::multimap<const aiNode*, unsigned int> MeshesByNodeMap;
- MeshesByNodeMap meshes;
-
-};
-
-}
-
-#endif // !! AI_STEPEXPORTER_H_INC