diff options
Diffstat (limited to 'libs/assimp/code/AssetLib/Blender/BlenderDNA.h')
| -rw-r--r-- | libs/assimp/code/AssetLib/Blender/BlenderDNA.h | 808 |
1 files changed, 808 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/Blender/BlenderDNA.h b/libs/assimp/code/AssetLib/Blender/BlenderDNA.h new file mode 100644 index 0000000..b2158f2 --- /dev/null +++ b/libs/assimp/code/AssetLib/Blender/BlenderDNA.h @@ -0,0 +1,808 @@ +/* +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 BlenderDNA.h + * @brief Blender `DNA` (file format specification embedded in + * blend file itself) loader. + */ +#ifndef INCLUDED_AI_BLEND_DNA_H +#define INCLUDED_AI_BLEND_DNA_H + +#include <assimp/BaseImporter.h> +#include <assimp/StreamReader.h> +#include <stdint.h> +#include <assimp/DefaultLogger.hpp> +#include <map> +#include <memory> + +// enable verbose log output. really verbose, so be careful. +#ifdef ASSIMP_BUILD_DEBUG +#define ASSIMP_BUILD_BLENDER_DEBUG +#endif + +// set this to non-zero to dump BlenderDNA stuff to dna.txt. +// you could set it on the assimp build command line too without touching it here. +// !!! please make sure this is set to 0 in the repo !!! +#ifndef ASSIMP_BUILD_BLENDER_DEBUG_DNA +#define ASSIMP_BUILD_BLENDER_DEBUG_DNA 0 +#endif + +// #define ASSIMP_BUILD_BLENDER_NO_STATS + +namespace Assimp { + +template <bool, bool> +class StreamReader; +typedef StreamReader<true, true> StreamReaderAny; + +namespace Blender { + +class FileDatabase; +struct FileBlockHead; + +template <template <typename> class TOUT> +class ObjectCache; + +// ------------------------------------------------------------------------------- +/** Exception class used by the blender loader to selectively catch exceptions + * thrown in its own code (DeadlyImportErrors thrown in general utility + * functions are untouched then). If such an exception is not caught by + * the loader itself, it will still be caught by Assimp due to its + * ancestry. */ +// ------------------------------------------------------------------------------- +struct Error : DeadlyImportError { + template <typename... T> + explicit Error(T &&...args) : + DeadlyImportError(args...) { + } +}; + +// ------------------------------------------------------------------------------- +/** The only purpose of this structure is to feed a virtual dtor into its + * descendents. It serves as base class for all data structure fields. */ +// ------------------------------------------------------------------------------- +struct ElemBase { + ElemBase() : + dna_type(nullptr) { + // empty + } + + virtual ~ElemBase() { + // empty + } + + /** Type name of the element. The type + * string points is the `c_str` of the `name` attribute of the + * corresponding `Structure`, that is, it is only valid as long + * as the DNA is not modified. The dna_type is only set if the + * data type is not static, i.e. a std::shared_ptr<ElemBase> + * in the scene description would have its type resolved + * at runtime, so this member is always set. */ + const char *dna_type; +}; + +// ------------------------------------------------------------------------------- +/** Represents a generic pointer to a memory location, which can be either 32 + * or 64 bits. These pointers are loaded from the BLEND file and finally + * fixed to point to the real, converted representation of the objects + * they used to point to.*/ +// ------------------------------------------------------------------------------- +struct Pointer { + Pointer() : + val() { + // empty + } + uint64_t val; +}; + +// ------------------------------------------------------------------------------- +/** Represents a generic offset within a BLEND file */ +// ------------------------------------------------------------------------------- +struct FileOffset { + FileOffset() : + val() { + // empty + } + uint64_t val; +}; + +// ------------------------------------------------------------------------------- +/** Dummy derivate of std::vector to be able to use it in templates simultaenously + * with std::shared_ptr, which takes only one template argument + * while std::vector takes three. Also we need to provide some special member + * functions of shared_ptr */ +// ------------------------------------------------------------------------------- +template <typename T> +class vector : public std::vector<T> { +public: + using std::vector<T>::resize; + using std::vector<T>::empty; + + void reset() { + resize(0); + } + + operator bool() const { + return !empty(); + } +}; + +// ------------------------------------------------------------------------------- +/** Mixed flags for use in #Field */ +// ------------------------------------------------------------------------------- +enum FieldFlags { + FieldFlag_Pointer = 0x1, + FieldFlag_Array = 0x2 +}; + +// ------------------------------------------------------------------------------- +/** Represents a single member of a data structure in a BLEND file */ +// ------------------------------------------------------------------------------- +struct Field { + std::string name; + std::string type; + + size_t size; + size_t offset; + + /** Size of each array dimension. For flat arrays, + * the second dimension is set to 1. */ + size_t array_sizes[2]; + + /** Any of the #FieldFlags enumerated values */ + unsigned int flags; +}; + +// ------------------------------------------------------------------------------- +/** Range of possible behaviors for fields absence in the input file. Some are + * mission critical so we need them, while others can silently be default + * initialized and no animations are harmed. */ +// ------------------------------------------------------------------------------- +enum ErrorPolicy { + /** Substitute default value and ignore */ + ErrorPolicy_Igno, + /** Substitute default value and write to log */ + ErrorPolicy_Warn, + /** Substitute a massive error message and crash the whole matrix. Its time for another zion */ + ErrorPolicy_Fail +}; + +#ifdef ASSIMP_BUILD_BLENDER_DEBUG +#define ErrorPolicy_Igno ErrorPolicy_Warn +#endif + +// ------------------------------------------------------------------------------- +/** Represents a data structure in a BLEND file. A Structure defines n fields + * and their locations and encodings the input stream. Usually, every + * Structure instance pertains to one equally-named data structure in the + * BlenderScene.h header. This class defines various utilities to map a + * binary `blob` read from the file to such a structure instance with + * meaningful contents. */ +// ------------------------------------------------------------------------------- +class Structure { + template <template <typename> class> + friend class ObjectCache; + +public: + Structure() : + cache_idx(static_cast<size_t>(-1)) { + // empty + } + + // publicly accessible members + std::string name; + vector<Field> fields; + std::map<std::string, size_t> indices; + + size_t size; + + // -------------------------------------------------------- + /** Access a field of the structure by its canonical name. The pointer version + * returns nullptr on failure while the reference version raises an import error. */ + inline const Field &operator[](const std::string &ss) const; + inline const Field *Get(const std::string &ss) const; + + // -------------------------------------------------------- + /** Access a field of the structure by its index */ + inline const Field &operator[](const size_t i) const; + + // -------------------------------------------------------- + inline bool operator==(const Structure &other) const { + return name == other.name; // name is meant to be an unique identifier + } + + // -------------------------------------------------------- + inline bool operator!=(const Structure &other) const { + return name != other.name; + } + + // -------------------------------------------------------- + /** Try to read an instance of the structure from the stream + * and attempt to convert to `T`. This is done by + * an appropriate specialization. If none is available, + * a compiler complain is the result. + * @param dest Destination value to be written + * @param db File database, including input stream. */ + template <typename T> + void Convert(T &dest, const FileDatabase &db) const; + + // -------------------------------------------------------- + // generic converter + template <typename T> + void Convert(std::shared_ptr<ElemBase> in, const FileDatabase &db) const; + + // -------------------------------------------------------- + // generic allocator + template <typename T> + std::shared_ptr<ElemBase> Allocate() const; + + // -------------------------------------------------------- + // field parsing for 1d arrays + template <int error_policy, typename T, size_t M> + void ReadFieldArray(T (&out)[M], const char *name, + const FileDatabase &db) const; + + // -------------------------------------------------------- + // field parsing for 2d arrays + template <int error_policy, typename T, size_t M, size_t N> + void ReadFieldArray2(T (&out)[M][N], const char *name, + const FileDatabase &db) const; + + // -------------------------------------------------------- + // field parsing for pointer or dynamic array types + // (std::shared_ptr) + // The return value indicates whether the data was already cached. + template <int error_policy, template <typename> class TOUT, typename T> + bool ReadFieldPtr(TOUT<T> &out, const char *name, + const FileDatabase &db, + bool non_recursive = false) const; + + // -------------------------------------------------------- + // field parsing for static arrays of pointer or dynamic + // array types (std::shared_ptr[]) + // The return value indicates whether the data was already cached. + template <int error_policy, template <typename> class TOUT, typename T, size_t N> + bool ReadFieldPtr(TOUT<T> (&out)[N], const char *name, + const FileDatabase &db) const; + + // -------------------------------------------------------- + // field parsing for `normal` values + // The return value indicates whether the data was already cached. + template <int error_policy, typename T> + void ReadField(T &out, const char *name, + const FileDatabase &db) const; + + // -------------------------------------------------------- + /** + * @brief field parsing for dynamic vectors + * @param[in] out vector of struct to be filled + * @param[in] name of field + * @param[in] db to access the file, dna, ... + * @return true when read was successful + */ + template <int error_policy, template <typename> class TOUT, typename T> + bool ReadFieldPtrVector(vector<TOUT<T>> &out, const char *name, const FileDatabase &db) const; + + /** + * @brief parses raw customdata + * @param[in] out shared_ptr to be filled + * @param[in] cdtype customdata type to read + * @param[in] name of field ptr + * @param[in] db to access the file, dna, ... + * @return true when read was successful + */ + template <int error_policy> + bool ReadCustomDataPtr(std::shared_ptr<ElemBase> &out, int cdtype, const char *name, const FileDatabase &db) const; + +private: + // -------------------------------------------------------- + template <template <typename> class TOUT, typename T> + bool ResolvePointer(TOUT<T> &out, const Pointer &ptrval, + const FileDatabase &db, const Field &f, + bool non_recursive = false) const; + + // -------------------------------------------------------- + template <template <typename> class TOUT, typename T> + bool ResolvePointer(vector<TOUT<T>> &out, const Pointer &ptrval, + const FileDatabase &db, const Field &f, bool) const; + + // -------------------------------------------------------- + bool ResolvePointer(std::shared_ptr<FileOffset> &out, const Pointer &ptrval, + const FileDatabase &db, const Field &f, bool) const; + + // -------------------------------------------------------- + inline const FileBlockHead *LocateFileBlockForAddress( + const Pointer &ptrval, + const FileDatabase &db) const; + +private: + // ------------------------------------------------------------------------------ + template <typename T> + T *_allocate(std::shared_ptr<T> &out, size_t &s) const { + out = std::shared_ptr<T>(new T()); + s = 1; + return out.get(); + } + + template <typename T> + T *_allocate(vector<T> &out, size_t &s) const { + out.resize(s); + return s ? &out.front() : nullptr; + } + + // -------------------------------------------------------- + template <int error_policy> + struct _defaultInitializer { + + template <typename T, unsigned int N> + void operator()(T (&out)[N], const char * = nullptr) { + for (unsigned int i = 0; i < N; ++i) { + out[i] = T(); + } + } + + template <typename T, unsigned int N, unsigned int M> + void operator()(T (&out)[N][M], const char * = nullptr) { + for (unsigned int i = 0; i < N; ++i) { + for (unsigned int j = 0; j < M; ++j) { + out[i][j] = T(); + } + } + } + + template <typename T> + void operator()(T &out, const char * = nullptr) { + out = T(); + } + }; + +private: + mutable size_t cache_idx; +}; + +// -------------------------------------------------------- +template <> +struct Structure::_defaultInitializer<ErrorPolicy_Warn> { + + template <typename T> + void operator()(T &out, const char *reason = "<add reason>") { + ASSIMP_LOG_WARN(reason); + + // ... and let the show go on + _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); + } +}; + +template <> +struct Structure::_defaultInitializer<ErrorPolicy_Fail> { + + template <typename T> + void operator()(T & /*out*/, const char * = "") { + // obviously, it is crucial that _DefaultInitializer is used + // only from within a catch clause. + throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error"); + } +}; + +// ------------------------------------------------------------------------------------------------------- +template <> +inline bool Structure ::ResolvePointer<std::shared_ptr, ElemBase>(std::shared_ptr<ElemBase> &out, + const Pointer &ptrval, + const FileDatabase &db, + const Field &f, + bool) const; + +// ------------------------------------------------------------------------------- +/** Represents the full data structure information for a single BLEND file. + * This data is extracted from the DNA1 chunk in the file. + * #DNAParser does the reading and represents currently the only place where + * DNA is altered.*/ +// ------------------------------------------------------------------------------- +class DNA { +public: + typedef void (Structure::*ConvertProcPtr)( + std::shared_ptr<ElemBase> in, + const FileDatabase &) const; + + typedef std::shared_ptr<ElemBase> ( + Structure::*AllocProcPtr)() const; + + typedef std::pair<AllocProcPtr, ConvertProcPtr> FactoryPair; + +public: + std::map<std::string, FactoryPair> converters; + vector<Structure> structures; + std::map<std::string, size_t> indices; + +public: + // -------------------------------------------------------- + /** Access a structure by its canonical name, the pointer version returns nullptr on failure + * while the reference version raises an error. */ + inline const Structure &operator[](const std::string &ss) const; + inline const Structure *Get(const std::string &ss) const; + + // -------------------------------------------------------- + /** Access a structure by its index */ + inline const Structure &operator[](const size_t i) const; + +public: + // -------------------------------------------------------- + /** Add structure definitions for all the primitive types, + * i.e. integer, short, char, float */ + void AddPrimitiveStructures(); + + // -------------------------------------------------------- + /** Fill the @c converters member with converters for all + * known data types. The implementation of this method is + * in BlenderScene.cpp and is machine-generated. + * Converters are used to quickly handle objects whose + * exact data type is a runtime-property and not yet + * known at compile time (consider Object::data).*/ + void RegisterConverters(); + + // -------------------------------------------------------- + /** Take an input blob from the stream, interpret it according to + * a its structure name and convert it to the intermediate + * representation. + * @param structure Destination structure definition + * @param db File database. + * @return A null pointer if no appropriate converter is available.*/ + std::shared_ptr<ElemBase> ConvertBlobToStructure( + const Structure &structure, + const FileDatabase &db) const; + + // -------------------------------------------------------- + /** Find a suitable conversion function for a given Structure. + * Such a converter function takes a blob from the input + * stream, reads as much as it needs, and builds up a + * complete object in intermediate representation. + * @param structure Destination structure definition + * @param db File database. + * @return A null pointer in .first if no appropriate converter is available.*/ + FactoryPair GetBlobToStructureConverter( + const Structure &structure, + const FileDatabase &db) const; + +#if ASSIMP_BUILD_BLENDER_DEBUG_DNA + // -------------------------------------------------------- + /** Dump the DNA to a text file. This is for debugging purposes. + * The output file is `dna.txt` in the current working folder*/ + void DumpToFile(); +#endif + + // -------------------------------------------------------- + /** Extract array dimensions from a C array declaration, such + * as `...[4][6]`. Returned string would be `...[][]`. + * @param out + * @param array_sizes Receive maximally two array dimensions, + * the second element is set to 1 if the array is flat. + * Both are set to 1 if the input is not an array. + * @throw DeadlyImportError if more than 2 dimensions are + * encountered. */ + static void ExtractArraySize( + const std::string &out, + size_t array_sizes[2]); +}; + +// special converters for primitive types +template <> +inline void Structure ::Convert<int>(int &dest, const FileDatabase &db) const; +template <> +inline void Structure ::Convert<short>(short &dest, const FileDatabase &db) const; +template <> +inline void Structure ::Convert<char>(char &dest, const FileDatabase &db) const; +template <> +inline void Structure ::Convert<float>(float &dest, const FileDatabase &db) const; +template <> +inline void Structure ::Convert<double>(double &dest, const FileDatabase &db) const; +template <> +inline void Structure ::Convert<Pointer>(Pointer &dest, const FileDatabase &db) const; + +// ------------------------------------------------------------------------------- +/** Describes a master file block header. Each master file sections holds n + * elements of a certain SDNA structure (or otherwise unspecified data). */ +// ------------------------------------------------------------------------------- +struct FileBlockHead { + // points right after the header of the file block + StreamReaderAny::pos start; + + std::string id; + size_t size; + + // original memory address of the data + Pointer address; + + // index into DNA + unsigned int dna_index; + + // number of structure instances to follow + size_t num; + + // file blocks are sorted by address to quickly locate specific memory addresses + bool operator<(const FileBlockHead &o) const { + return address.val < o.address.val; + } + + // for std::upper_bound + operator const Pointer &() const { + return address; + } +}; + +// for std::upper_bound +inline bool operator<(const Pointer &a, const Pointer &b) { + return a.val < b.val; +} + +// ------------------------------------------------------------------------------- +/** Utility to read all master file blocks in turn. */ +// ------------------------------------------------------------------------------- +class SectionParser { +public: + // -------------------------------------------------------- + /** @param stream Inout stream, must point to the + * first section in the file. Call Next() once + * to have it read. + * @param ptr64 Pointer size in file is 64 bits? */ + SectionParser(StreamReaderAny &stream, bool ptr64) : + stream(stream), ptr64(ptr64) { + current.size = current.start = 0; + } + +public: + // -------------------------------------------------------- + const FileBlockHead &GetCurrent() const { + return current; + } + +public: + // -------------------------------------------------------- + /** Advance to the next section. + * @throw DeadlyImportError if the last chunk was passed. */ + void Next(); + +public: + FileBlockHead current; + StreamReaderAny &stream; + bool ptr64; +}; + +#ifndef ASSIMP_BUILD_BLENDER_NO_STATS +// ------------------------------------------------------------------------------- +/** Import statistics, i.e. number of file blocks read*/ +// ------------------------------------------------------------------------------- +class Statistics { + +public: + Statistics() : + fields_read(), pointers_resolved(), cache_hits() + // , blocks_read () + , + cached_objects() {} + +public: + /** total number of fields we read */ + unsigned int fields_read; + + /** total number of resolved pointers */ + unsigned int pointers_resolved; + + /** number of pointers resolved from the cache */ + unsigned int cache_hits; + + /** number of blocks (from FileDatabase::entries) + we did actually read from. */ + // unsigned int blocks_read; + + /** objects in FileData::cache */ + unsigned int cached_objects; +}; +#endif + +// ------------------------------------------------------------------------------- +/** The object cache - all objects addressed by pointers are added here. This + * avoids circular references and avoids object duplication. */ +// ------------------------------------------------------------------------------- +template <template <typename> class TOUT> +class ObjectCache { +public: + typedef std::map<Pointer, TOUT<ElemBase>> StructureCache; + +public: + ObjectCache(const FileDatabase &db) : + db(db) { + // currently there are only ~400 structure records per blend file. + // we read only a small part of them and don't cache objects + // which we don't need, so this should suffice. + caches.reserve(64); + } + +public: + // -------------------------------------------------------- + /** Check whether a specific item is in the cache. + * @param s Data type of the item + * @param out Output pointer. Unchanged if the + * cache doesn't know the item yet. + * @param ptr Item address to look for. */ + template <typename T> + void get( + const Structure &s, + TOUT<T> &out, + const Pointer &ptr) const; + + // -------------------------------------------------------- + /** Add an item to the cache after the item has + * been fully read. Do not insert anything that + * may be faulty or might cause the loading + * to abort. + * @param s Data type of the item + * @param out Item to insert into the cache + * @param ptr address (cache key) of the item. */ + template <typename T> + void set(const Structure &s, + const TOUT<T> &out, + const Pointer &ptr); + +private: + mutable vector<StructureCache> caches; + const FileDatabase &db; +}; + +// ------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------- +template <> +class ObjectCache<Blender::vector> { +public: + ObjectCache(const FileDatabase &) {} + + template <typename T> + void get(const Structure &, vector<T> &, const Pointer &) {} + template <typename T> + void set(const Structure &, const vector<T> &, const Pointer &) {} +}; + +#ifdef _MSC_VER +#pragma warning(disable : 4355) +#endif + +// ------------------------------------------------------------------------------- +/** Memory representation of a full BLEND file and all its dependencies. The + * output aiScene is constructed from an instance of this data structure. */ +// ------------------------------------------------------------------------------- +class FileDatabase { + template <template <typename> class TOUT> + friend class ObjectCache; + +public: + FileDatabase() : + _cacheArrays(*this), _cache(*this), next_cache_idx() {} + +public: + // publicly accessible fields + bool i64bit; + bool little; + + DNA dna; + std::shared_ptr<StreamReaderAny> reader; + vector<FileBlockHead> entries; + +public: + Statistics &stats() const { + return _stats; + } + + // For all our templates to work on both shared_ptr's and vector's + // using the same code, a dummy cache for arrays is provided. Actually, + // arrays of objects are never cached because we can't easily + // ensure their proper destruction. + template <typename T> + ObjectCache<std::shared_ptr> &cache(std::shared_ptr<T> & /*in*/) const { + return _cache; + } + + template <typename T> + ObjectCache<vector> &cache(vector<T> & /*in*/) const { + return _cacheArrays; + } + +private: +#ifndef ASSIMP_BUILD_BLENDER_NO_STATS + mutable Statistics _stats; +#endif + + mutable ObjectCache<vector> _cacheArrays; + mutable ObjectCache<std::shared_ptr> _cache; + + mutable size_t next_cache_idx; +}; + +#ifdef _MSC_VER +#pragma warning(default : 4355) +#endif + +// ------------------------------------------------------------------------------- +/** Factory to extract a #DNA from the DNA1 file block in a BLEND file. */ +// ------------------------------------------------------------------------------- +class DNAParser { + +public: + /** Bind the parser to a empty DNA and an input stream */ + DNAParser(FileDatabase &db) : + db(db) {} + +public: + // -------------------------------------------------------- + /** Locate the DNA in the file and parse it. The input + * stream is expected to point to the beginning of the DN1 + * chunk at the time this method is called and is + * undefined afterwards. + * @throw DeadlyImportError if the DNA cannot be read. + * @note The position of the stream pointer is undefined + * afterwards.*/ + void Parse(); + +public: + /** Obtain a reference to the extracted DNA information */ + const Blender::DNA &GetDNA() const { + return db.dna; + } + +private: + FileDatabase &db; +}; + +/** +* @brief read CustomData's data to ptr to mem +* @param[out] out memory ptr to set +* @param[in] cdtype to read +* @param[in] cnt cnt of elements to read +* @param[in] db to read elements from +* @return true when ok +*/ +bool readCustomData(std::shared_ptr<ElemBase> &out, int cdtype, size_t cnt, const FileDatabase &db); + +} // namespace Blender +} // namespace Assimp + +#include "BlenderDNA.inl" + +#endif |