From 058f98a63658dc1a2579826ba167fd61bed1e21f Mon Sep 17 00:00:00 2001 From: sanine Date: Fri, 4 Mar 2022 10:47:15 -0600 Subject: add assimp submodule --- .../code/AssetLib/STEPParser/STEPFileReader.cpp | 563 +++++++++++++++++++++ 1 file changed, 563 insertions(+) create mode 100644 src/mesh/assimp-master/code/AssetLib/STEPParser/STEPFileReader.cpp (limited to 'src/mesh/assimp-master/code/AssetLib/STEPParser/STEPFileReader.cpp') diff --git a/src/mesh/assimp-master/code/AssetLib/STEPParser/STEPFileReader.cpp b/src/mesh/assimp-master/code/AssetLib/STEPParser/STEPFileReader.cpp new file mode 100644 index 0000000..2bcfa17 --- /dev/null +++ b/src/mesh/assimp-master/code/AssetLib/STEPParser/STEPFileReader.cpp @@ -0,0 +1,563 @@ +/* +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. + +---------------------------------------------------------------------- +*/ + +/** @file STEPFileReader.cpp + * @brief Implementation of the STEP file parser, which fills a + * STEP::DB with data read from a file. + */ + +#include "STEPFileReader.h" +#include "STEPFileEncoding.h" +#include +#include +#include +#include +#include + +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()) +{ + return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast( (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()) +{ + return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast( (Formatter::format(),prefix,"(entity #",entity,") ",s)); +} + + +// ------------------------------------------------------------------------------------------------ +STEP::SyntaxError::SyntaxError (const std::string& s,uint64_t line /* = LINE_NOT_SPECIFIED */) +: DeadlyImportError(AddLineNumber(s,line)) +{ + +} + +// ------------------------------------------------------------------------------------------------ +STEP::TypeError::TypeError (const std::string& s,uint64_t entity /* = ENTITY_NOT_SPECIFIED */,uint64_t line /*= LINE_NOT_SPECIFIED*/) +: DeadlyImportError(AddLineNumber(AddEntityID(s,entity),line)) +{ + +} + +static const char *ISO_Token = "ISO-10303-21;"; +static const char *FILE_SCHEMA_Token = "FILE_SCHEMA"; +// ------------------------------------------------------------------------------------------------ +STEP::DB* STEP::ReadFileHeader(std::shared_ptr stream) { + std::shared_ptr reader = std::shared_ptr(new StreamReaderLE(std::move(stream))); + std::unique_ptr db = std::unique_ptr(new STEP::DB(reader)); + + LineSplitter &splitter = db->GetSplitter(); + if (!splitter || *splitter != ISO_Token ) { + throw STEP::SyntaxError("expected magic token: " + std::string( ISO_Token ), 1); + } + + HeaderInfo& head = db->GetHeader(); + for(++splitter; splitter; ++splitter) { + const std::string& s = *splitter; + if (s == "DATA;") { + // here we go, header done, start of data section + ++splitter; + break; + } + + // want one-based line numbers for human readers, so +1 + const uint64_t line = splitter.get_index()+1; + + if (s.substr(0,11) == FILE_SCHEMA_Token) { + const char* sz = s.c_str()+11; + SkipSpaces(sz,&sz); + std::shared_ptr< const EXPRESS::DataType > schema = EXPRESS::DataType::Parse(sz); + + // the file schema should be a regular list entity, although it usually contains exactly one entry + // since the list itself is contained in a regular parameter list, we actually have + // two nested lists. + const EXPRESS::LIST* list = dynamic_cast(schema.get()); + if (list && list->GetSize()) { + list = dynamic_cast( (*list)[0].get() ); + if (!list) { + throw STEP::SyntaxError("expected FILE_SCHEMA to be a list",line); + } + + // XXX need support for multiple schemas? + if (list->GetSize() > 1) { + ASSIMP_LOG_WARN(AddLineNumber("multiple schemas currently not supported",line)); + } + const EXPRESS::STRING *string = dynamic_cast((*list)[0].get()); + if (!list->GetSize() || nullptr == string ) { + throw STEP::SyntaxError("expected FILE_SCHEMA to contain a single string literal",line); + } + head.fileSchema = *string; + } + } + + // XXX handle more header fields + } + + return db.release(); +} + + +namespace { + +// ------------------------------------------------------------------------------------------------ +// check whether the given line contains an entity definition (i.e. starts with "#=") +bool IsEntityDef(const std::string& snext) +{ + if (snext[0] == '#') { + // it is only a new entity if it has a '=' after the + // entity ID. + for(std::string::const_iterator it = snext.begin()+1; it != snext.end(); ++it) { + if (*it == '=') { + return true; + } + if ((*it < '0' || *it > '9') && *it != ' ') { + break; + } + } + } + return false; +} + +} + + +// ------------------------------------------------------------------------------------------------ +void STEP::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) +{ + db.SetSchema(scheme); + db.SetTypesToTrack(types_to_track,len); + db.SetInverseIndicesToTrack(inverse_indices_to_track,len2); + + const DB::ObjectMap& map = db.GetObjects(); + LineSplitter& splitter = db.GetSplitter(); + + while (splitter) { + bool has_next = false; + std::string s = *splitter; + if (s == "ENDSEC;") { + break; + } + s.erase(std::remove(s.begin(), s.end(), ' '), s.end()); + + // want one-based line numbers for human readers, so +1 + const uint64_t line = splitter.get_index()+1; + // LineSplitter already ignores empty lines + ai_assert(s.length()); + if (s[0] != '#') { + ASSIMP_LOG_WARN(AddLineNumber("expected token \'#\'",line)); + ++splitter; + continue; + } + // --- + // extract id, entity class name and argument string, + // but don't create the actual object yet. + // --- + const std::string::size_type n0 = s.find_first_of('='); + if (n0 == std::string::npos) { + ASSIMP_LOG_WARN(AddLineNumber("expected token \'=\'",line)); + ++splitter; + continue; + } + + const uint64_t id = strtoul10_64(s.substr(1,n0-1).c_str()); + if (!id) { + ASSIMP_LOG_WARN(AddLineNumber("expected positive, numeric entity id",line)); + ++splitter; + continue; + } + std::string::size_type n1 = s.find_first_of('(',n0); + if (n1 == std::string::npos) { + has_next = true; + bool ok = false; + for( ++splitter; splitter; ++splitter) { + const std::string& snext = *splitter; + if (snext.empty()) { + continue; + } + + // the next line doesn't start an entity, so maybe it is + // just a continuation for this line, keep going + if (!IsEntityDef(snext)) { + s.append(snext); + n1 = s.find_first_of('(',n0); + ok = (n1 != std::string::npos); + } + else { + break; + } + } + + if(!ok) { + ASSIMP_LOG_WARN(AddLineNumber("expected token \'(\'",line)); + continue; + } + } + + std::string::size_type n2 = s.find_last_of(')'); + if (n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';') { + has_next = true; + bool ok = false; + for( ++splitter; splitter; ++splitter) { + const std::string& snext = *splitter; + if (snext.empty()) { + continue; + } + + // the next line doesn't start an entity, so maybe it is + // just a continuation for this line, keep going + if (!IsEntityDef(snext)) { + s.append(snext); + n2 = s.find_last_of(')'); + ok = !(n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';'); + } else { + break; + } + } + if(!ok) { + ASSIMP_LOG_WARN(AddLineNumber("expected token \')\'",line)); + continue; + } + } + + if (map.find(id) != map.end()) { + ASSIMP_LOG_WARN(AddLineNumber((Formatter::format(),"an object with the id #",id," already exists"),line)); + } + + std::string::size_type ns = n0; + do { + ++ns; + } while (IsSpace(s.at(ns))); + std::string::size_type ne = n1; + do { + --ne; + } while (IsSpace(s.at(ne))); + std::string type = s.substr(ns, ne - ns + 1); + type = ai_tolower(type); + const char* sz = scheme.GetStaticStringForToken(type); + if(sz) { + const std::string::size_type szLen = n2-n1+1; + char* const copysz = new char[szLen+1]; + std::copy(s.c_str()+n1,s.c_str()+n2+1,copysz); + copysz[szLen] = '\0'; + db.InternInsert(new LazyObject(db,id,line,sz,copysz)); + } + if(!has_next) { + ++splitter; + } + } + + if (!splitter) { + ASSIMP_LOG_WARN("STEP: ignoring unexpected EOF"); + } + + if ( !DefaultLogger::isNullLogger()){ + ASSIMP_LOG_DEBUG("STEP: got ",map.size()," object records with ", + db.GetRefs().size()," inverse index entries"); + } +} + +// ------------------------------------------------------------------------------------------------ +std::shared_ptr EXPRESS::DataType::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= nullptr*/) +{ + const char* cur = inout; + SkipSpaces(&cur); + if (*cur == ',' || IsSpaceOrNewLine(*cur)) { + throw STEP::SyntaxError("unexpected token, expected parameter",line); + } + + // just skip over constructions such as IFCPLANEANGLEMEASURE(0.01) and read only the value + if (schema) { + bool ok = false; + for(const char* t = cur; *t && *t != ')' && *t != ','; ++t) { + if (*t=='(') { + if (!ok) { + break; + } + for(--t;IsSpace(*t);--t); + std::string s(cur,static_cast(t-cur+1)); + std::transform(s.begin(),s.end(),s.begin(),&ai_tolower ); + if (schema->IsKnownToken(s)) { + for(cur = t+1;*cur++ != '(';); + std::shared_ptr dt = Parse(cur); + inout = *cur ? cur+1 : cur; + return dt; + } + break; + } + else if (!IsSpace(*t)) { + ok = true; + } + } + } + + if (*cur == '*' ) { + inout = cur+1; + return std::make_shared(); + } + else if (*cur == '$' ) { + inout = cur+1; + return std::make_shared(); + } + else if (*cur == '(' ) { + // start of an aggregate, further parsing is done by the LIST factory constructor + inout = cur; + return EXPRESS::LIST::Parse(inout,line,schema); + } + else if (*cur == '.' ) { + // enum (includes boolean) + const char* start = ++cur; + for(;*cur != '.';++cur) { + if (*cur == '\0') { + throw STEP::SyntaxError("enum not closed",line); + } + } + inout = cur+1; + return std::make_shared(std::string(start, static_cast(cur-start) )); + } + else if (*cur == '#' ) { + // object reference + return std::make_shared(strtoul10_64(++cur,&inout)); + } + else if (*cur == '\'' ) { + // string literal + const char* start = ++cur; + + for(;*cur != '\'';++cur) { + if (*cur == '\0') { + throw STEP::SyntaxError("string literal not closed",line); + } + } + + if (cur[1] == '\'') { + // Vesanen: more than 2 escaped ' in one literal! + do { + for(cur += 2;*cur != '\'';++cur) { + if (*cur == '\0') { + throw STEP::SyntaxError("string literal not closed",line); + } + } + } + while(cur[1] == '\''); + } + + inout = cur + 1; + + // assimp is supposed to output UTF8 strings, so we have to deal + // with foreign encodings. + std::string stemp = std::string(start, static_cast(cur - start)); + if(!StringToUTF8(stemp)) { + // TODO: route this to a correct logger with line numbers etc., better error messages + ASSIMP_LOG_ERROR("an error occurred reading escape sequences in ASCII text"); + } + + return std::make_shared(stemp); + } + else if (*cur == '\"' ) { + throw STEP::SyntaxError("binary data not supported yet",line); + } + + // else -- must be a number. if there is a decimal dot in it, + // parse it as real value, otherwise as integer. + const char* start = cur; + for(;*cur && *cur != ',' && *cur != ')' && !IsSpace(*cur);++cur) { + if (*cur == '.') { + double f; + inout = fast_atoreal_move(start,f); + return std::make_shared(f); + } + } + + bool neg = false; + if (*start == '-') { + neg = true; + ++start; + } + else if (*start == '+') { + ++start; + } + int64_t num = static_cast( strtoul10_64(start,&inout) ); + return std::make_shared(neg?-num:num); +} + +// ------------------------------------------------------------------------------------------------ +std::shared_ptr EXPRESS::LIST::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= nullptr*/) { + const std::shared_ptr list = std::make_shared(); + EXPRESS::LIST::MemberList& members = list->members; + + const char* cur = inout; + if (*cur++ != '(') { + throw STEP::SyntaxError("unexpected token, expected \'(\' token at beginning of list",line); + } + + // estimate the number of items upfront - lists can grow large + size_t count = 1; + for(const char* c=cur; *c && *c != ')'; ++c) { + count += (*c == ',' ? 1 : 0); + } + + members.reserve(count); + + for(;;++cur) { + if (!*cur) { + throw STEP::SyntaxError("unexpected end of line while reading list"); + } + SkipSpaces(cur,&cur); + if (*cur == ')') { + break; + } + + members.push_back( EXPRESS::DataType::Parse(cur,line,schema)); + SkipSpaces(cur,&cur); + + if (*cur != ',') { + if (*cur == ')') { + break; + } + throw STEP::SyntaxError("unexpected token, expected \',\' or \')\' token after list element",line); + } + } + + inout = cur+1; + return list; +} + +// ------------------------------------------------------------------------------------------------ +static void handleSkippedDepthFromToken(const char *a, int64_t &skip_depth ) { + if (*a == '(') { + ++skip_depth; + } else if (*a == ')') { + --skip_depth; + } +} + +// ------------------------------------------------------------------------------------------------ +static int64_t getIdFromToken(const char *a) { + const char *tmp; + const int64_t num = static_cast(strtoul10_64(a + 1, &tmp)); + + return num; +} + +// ------------------------------------------------------------------------------------------------ +STEP::LazyObject::LazyObject(DB& db, uint64_t id,uint64_t /*line*/, const char* const type,const char* args) +: id(id) +, type(type) +, db(db) +, args(args) +, obj() { + // find any external references and store them in the database. + // this helps us emulate STEPs INVERSE fields. + if (!db.KeepInverseIndicesForType(type)) { + return; + } + + // do a quick scan through the argument tuple and watch out for entity references + const char *a( args ); + int64_t skip_depth( 0 ); + while ( *a ) { + handleSkippedDepthFromToken(a, skip_depth); + /*if (*a == '(') { + ++skip_depth; + } else if (*a == ')') { + --skip_depth; + }*/ + + if (skip_depth >= 1 && *a=='#') { + if (*(a + 1) != '#') { + /*const char *tmp; + const int64_t num = static_cast(strtoul10_64(a + 1, &tmp)); + db.MarkRef(num, id);*/ + db.MarkRef(getIdFromToken(a), id); + } else { + ++a; + } + } + ++a; + } +} + +// ------------------------------------------------------------------------------------------------ +STEP::LazyObject::~LazyObject() { + // make sure the right dtor/operator delete get called + if (obj) { + delete obj; + } else { + delete[] args; + } +} + +// ------------------------------------------------------------------------------------------------ +void STEP::LazyObject::LazyInit() const { + const EXPRESS::ConversionSchema& schema = db.GetSchema(); + STEP::ConvertObjectProc proc = schema.GetConverterProc(type); + + if (!proc) { + throw STEP::TypeError("unknown object type: " + std::string(type),id); + } + + const char* acopy = args; + std::shared_ptr conv_args = EXPRESS::LIST::Parse(acopy,(uint64_t)STEP::SyntaxError::LINE_NOT_SPECIFIED,&db.GetSchema()); + delete[] args; + args = nullptr; + + // if the converter fails, it should throw an exception, but it should never return nullptr + try { + obj = proc(db,*conv_args); + } + catch(const TypeError& t) { + // augment line and entity information + throw TypeError(t.what(),id); + } + ++db.evaluated_count; + ai_assert(obj); + + // store the original id in the object instance + obj->SetID(id); +} -- cgit v1.2.1