diff options
Diffstat (limited to 'libs/assimp/code/AssetLib/Assbin')
| -rw-r--r-- | libs/assimp/code/AssetLib/Assbin/AssbinExporter.cpp | 68 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/Assbin/AssbinExporter.h | 60 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp | 833 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.h | 65 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/Assbin/AssbinLoader.cpp | 730 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/Assbin/AssbinLoader.h | 99 |
6 files changed, 0 insertions, 1855 deletions
diff --git a/libs/assimp/code/AssetLib/Assbin/AssbinExporter.cpp b/libs/assimp/code/AssetLib/Assbin/AssbinExporter.cpp deleted file mode 100644 index 149b3c5..0000000 --- a/libs/assimp/code/AssetLib/Assbin/AssbinExporter.cpp +++ /dev/null @@ -1,68 +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. - ----------------------------------------------------------------------- -*/ -/** @file AssbinExporter.cpp - * ASSBIN exporter main code - */ - -#ifndef ASSIMP_BUILD_NO_EXPORT -#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER - -#include "AssbinFileWriter.h" - -#include <assimp/scene.h> -#include <assimp/Exporter.hpp> -#include <assimp/IOSystem.hpp> - -namespace Assimp { - -void ExportSceneAssbin(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) { - DumpSceneToAssbin( - pFile, - "\0", // no command(s). - pIOSystem, - pScene, - false, // shortened? - false); // compressed? -} -} // end of namespace Assimp - -#endif // ASSIMP_BUILD_NO_ASSBIN_EXPORTER -#endif // ASSIMP_BUILD_NO_EXPORT diff --git a/libs/assimp/code/AssetLib/Assbin/AssbinExporter.h b/libs/assimp/code/AssetLib/Assbin/AssbinExporter.h deleted file mode 100644 index 1801c16..0000000 --- a/libs/assimp/code/AssetLib/Assbin/AssbinExporter.h +++ /dev/null @@ -1,60 +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. - ----------------------------------------------------------------------- -*/ - -/** @file AssbinExporter.h - * ASSBIN Exporter Main Header - */ -#pragma once -#ifndef AI_ASSBINEXPORTER_H_INC -#define AI_ASSBINEXPORTER_H_INC - -#include <assimp/defs.h> - -#ifndef ASSIMP_BUILD_NO_EXPORT - -// nothing really needed here - reserved for future use like properties -namespace Assimp { - -void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/); - -} -#endif -#endif // AI_ASSBINEXPORTER_H_INC diff --git a/libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp b/libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp deleted file mode 100644 index 1d16f17..0000000 --- a/libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp +++ /dev/null @@ -1,833 +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. - ----------------------------------------------------------------------- -*/ -/** @file AssbinFileWriter.cpp - * @brief Implementation of Assbin file writer. - */ - -#include "AssbinFileWriter.h" -#include "Common/assbin_chunks.h" -#include "PostProcessing/ProcessHelper.h" - -#include <assimp/Exceptional.h> -#include <assimp/version.h> -#include <assimp/IOStream.hpp> - -#ifdef ASSIMP_BUILD_NO_OWN_ZLIB -#include <zlib.h> -#else -#include "../contrib/zlib/zlib.h" -#endif - -#include <ctime> - -#if _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4706) -#endif // _MSC_VER - -namespace Assimp { - -template <typename T> -size_t Write(IOStream *stream, const T &v) { - return stream->Write(&v, sizeof(T), 1); -} - -// ----------------------------------------------------------------------------------- -// Serialize an aiString -template <> -inline size_t Write<aiString>(IOStream *stream, const aiString &s) { - const size_t s2 = (uint32_t)s.length; - stream->Write(&s, 4, 1); - stream->Write(s.data, s2, 1); - - return s2 + 4; -} - -// ----------------------------------------------------------------------------------- -// Serialize an unsigned int as uint32_t -template <> -inline size_t Write<unsigned int>(IOStream *stream, const unsigned int &w) { - const uint32_t t = (uint32_t)w; - if (w > t) { - // this shouldn't happen, integers in Assimp data structures never exceed 2^32 - throw DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion"); - } - - stream->Write(&t, 4, 1); - - return 4; -} - -// ----------------------------------------------------------------------------------- -// Serialize an unsigned int as uint16_t -template <> -inline size_t Write<uint16_t>(IOStream *stream, const uint16_t &w) { - static_assert(sizeof(uint16_t) == 2, "sizeof(uint16_t)==2"); - stream->Write(&w, 2, 1); - - return 2; -} - -// ----------------------------------------------------------------------------------- -// Serialize a float -template <> -inline size_t Write<float>(IOStream *stream, const float &f) { - static_assert(sizeof(float) == 4, "sizeof(float)==4"); - stream->Write(&f, 4, 1); - - return 4; -} - -// ----------------------------------------------------------------------------------- -// Serialize a double -template <> -inline size_t Write<double>(IOStream *stream, const double &f) { - static_assert(sizeof(double) == 8, "sizeof(double)==8"); - stream->Write(&f, 8, 1); - - return 8; -} - -// ----------------------------------------------------------------------------------- -// Serialize a vec3 -template <> -inline size_t Write<aiVector3D>(IOStream *stream, const aiVector3D &v) { - size_t t = Write<float>(stream, v.x); - t += Write<float>(stream, v.y); - t += Write<float>(stream, v.z); - - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a color value -template <> -inline size_t Write<aiColor3D>(IOStream *stream, const aiColor3D &v) { - size_t t = Write<float>(stream, v.r); - t += Write<float>(stream, v.g); - t += Write<float>(stream, v.b); - - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a color value -template <> -inline size_t Write<aiColor4D>(IOStream *stream, const aiColor4D &v) { - size_t t = Write<float>(stream, v.r); - t += Write<float>(stream, v.g); - t += Write<float>(stream, v.b); - t += Write<float>(stream, v.a); - - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a quaternion -template <> -inline size_t Write<aiQuaternion>(IOStream *stream, const aiQuaternion &v) { - size_t t = Write<float>(stream, v.w); - t += Write<float>(stream, v.x); - t += Write<float>(stream, v.y); - t += Write<float>(stream, v.z); - ai_assert(t == 16); - - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a vertex weight -template <> -inline size_t Write<aiVertexWeight>(IOStream *stream, const aiVertexWeight &v) { - size_t t = Write<unsigned int>(stream, v.mVertexId); - - return t + Write<float>(stream, v.mWeight); -} - -constexpr size_t MatrixSize = 64; - -// ----------------------------------------------------------------------------------- -// Serialize a mat4x4 -template <> -inline size_t Write<aiMatrix4x4>(IOStream *stream, const aiMatrix4x4 &m) { - for (unsigned int i = 0; i < 4; ++i) { - for (unsigned int i2 = 0; i2 < 4; ++i2) { - Write<float>(stream, m[i][i2]); - } - } - - return MatrixSize; -} - -// ----------------------------------------------------------------------------------- -// Serialize an aiVectorKey -template <> -inline size_t Write<aiVectorKey>(IOStream *stream, const aiVectorKey &v) { - const size_t t = Write<double>(stream, v.mTime); - return t + Write<aiVector3D>(stream, v.mValue); -} - -// ----------------------------------------------------------------------------------- -// Serialize an aiQuatKey -template <> -inline size_t Write<aiQuatKey>(IOStream *stream, const aiQuatKey &v) { - const size_t t = Write<double>(stream, v.mTime); - return t + Write<aiQuaternion>(stream, v.mValue); -} - -template <typename T> -inline size_t WriteBounds(IOStream *stream, const T *in, unsigned int size) { - T minc, maxc; - ArrayBounds(in, size, minc, maxc); - - const size_t t = Write<T>(stream, minc); - return t + Write<T>(stream, maxc); -} - -// We use this to write out non-byte arrays so that we write using the specializations. -// This way we avoid writing out extra bytes that potentially come from struct alignment. -template <typename T> -inline size_t WriteArray(IOStream *stream, const T *in, unsigned int size) { - size_t n = 0; - for (unsigned int i = 0; i < size; i++) - n += Write<T>(stream, in[i]); - - return n; -} - -// ---------------------------------------------------------------------------------- -/** @class AssbinChunkWriter - * @brief Chunk writer mechanism for the .assbin file structure - * - * This is a standard in-memory IOStream (most of the code is based on BlobIOStream), - * the difference being that this takes another IOStream as a "container" in the - * constructor, and when it is destroyed, it appends the magic number, the chunk size, - * and the chunk contents to the container stream. This allows relatively easy chunk - * chunk construction, even recursively. - */ -class AssbinChunkWriter : public IOStream { -private: - uint8_t *buffer; - uint32_t magic; - IOStream *container; - size_t cur_size, cursor, initial; - -private: - // ------------------------------------------------------------------- - void Grow(size_t need = 0) { - size_t new_size = std::max(initial, std::max(need, cur_size + (cur_size >> 1))); - - const uint8_t *const old = buffer; - buffer = new uint8_t[new_size]; - - if (old) { - memcpy(buffer, old, cur_size); - delete[] old; - } - - cur_size = new_size; - } - -public: - AssbinChunkWriter(IOStream *container, uint32_t magic, size_t initial = 4096) : - buffer(nullptr), - magic(magic), - container(container), - cur_size(0), - cursor(0), - initial(initial) { - // empty - } - - ~AssbinChunkWriter() override { - if (container) { - container->Write(&magic, sizeof(uint32_t), 1); - container->Write(&cursor, sizeof(uint32_t), 1); - container->Write(buffer, 1, cursor); - } - if (buffer) delete[] buffer; - } - - void *GetBufferPointer() { return buffer; } - - size_t Read(void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override { - return 0; - } - - aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) override { - return aiReturn_FAILURE; - } - - size_t Tell() const override { - return cursor; - } - - void Flush() override { - // not implemented - } - - size_t FileSize() const override { - return cursor; - } - - size_t Write(const void *pvBuffer, size_t pSize, size_t pCount) override { - pSize *= pCount; - if (cursor + pSize > cur_size) { - Grow(cursor + pSize); - } - - memcpy(buffer + cursor, pvBuffer, pSize); - cursor += pSize; - - return pCount; - } -}; - -// ---------------------------------------------------------------------------------- -/** @class AssbinFileWriter - * @brief Assbin file writer class - * - * This class writes an .assbin file, and is responsible for the file layout. - */ -class AssbinFileWriter { -private: - bool shortened; - bool compressed; - -protected: - // ----------------------------------------------------------------------------------- - void WriteBinaryNode(IOStream *container, const aiNode *node) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AINODE); - - unsigned int nb_metadata = (node->mMetaData != nullptr ? node->mMetaData->mNumProperties : 0); - - Write<aiString>(&chunk, node->mName); - Write<aiMatrix4x4>(&chunk, node->mTransformation); - Write<unsigned int>(&chunk, node->mNumChildren); - Write<unsigned int>(&chunk, node->mNumMeshes); - Write<unsigned int>(&chunk, nb_metadata); - - for (unsigned int i = 0; i < node->mNumMeshes; ++i) { - Write<unsigned int>(&chunk, node->mMeshes[i]); - } - - for (unsigned int i = 0; i < node->mNumChildren; ++i) { - WriteBinaryNode(&chunk, node->mChildren[i]); - } - - for (unsigned int i = 0; i < nb_metadata; ++i) { - const aiString &key = node->mMetaData->mKeys[i]; - aiMetadataType type = node->mMetaData->mValues[i].mType; - void *value = node->mMetaData->mValues[i].mData; - - Write<aiString>(&chunk, key); - Write<uint16_t>(&chunk, (uint16_t)type); - - switch (type) { - case AI_BOOL: - Write<bool>(&chunk, *((bool *)value)); - break; - case AI_INT32: - Write<int32_t>(&chunk, *((int32_t *)value)); - break; - case AI_UINT64: - Write<uint64_t>(&chunk, *((uint64_t *)value)); - break; - case AI_FLOAT: - Write<float>(&chunk, *((float *)value)); - break; - case AI_DOUBLE: - Write<double>(&chunk, *((double *)value)); - break; - case AI_AISTRING: - Write<aiString>(&chunk, *((aiString *)value)); - break; - case AI_AIVECTOR3D: - Write<aiVector3D>(&chunk, *((aiVector3D *)value)); - break; -#ifdef SWIG - case FORCE_32BIT: -#endif // SWIG - default: - break; - } - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryTexture(IOStream *container, const aiTexture *tex) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AITEXTURE); - - Write<unsigned int>(&chunk, tex->mWidth); - Write<unsigned int>(&chunk, tex->mHeight); - // Write the texture format, but don't include the null terminator. - chunk.Write(tex->achFormatHint, sizeof(char), HINTMAXTEXTURELEN - 1); - - if (!shortened) { - if (!tex->mHeight) { - chunk.Write(tex->pcData, 1, tex->mWidth); - } else { - chunk.Write(tex->pcData, 1, tex->mWidth * tex->mHeight * 4); - } - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryBone(IOStream *container, const aiBone *b) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIBONE); - - Write<aiString>(&chunk, b->mName); - Write<unsigned int>(&chunk, b->mNumWeights); - Write<aiMatrix4x4>(&chunk, b->mOffsetMatrix); - - // for the moment we write dumb min/max values for the bones, too. - // maybe I'll add a better, hash-like solution later - if (shortened) { - WriteBounds(&chunk, b->mWeights, b->mNumWeights); - } // else write as usual - else - WriteArray<aiVertexWeight>(&chunk, b->mWeights, b->mNumWeights); - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryMesh(IOStream *container, const aiMesh *mesh) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIMESH); - - Write<unsigned int>(&chunk, mesh->mPrimitiveTypes); - Write<unsigned int>(&chunk, mesh->mNumVertices); - Write<unsigned int>(&chunk, mesh->mNumFaces); - Write<unsigned int>(&chunk, mesh->mNumBones); - Write<unsigned int>(&chunk, mesh->mMaterialIndex); - - // first of all, write bits for all existent vertex components - unsigned int c = 0; - if (mesh->mVertices) { - c |= ASSBIN_MESH_HAS_POSITIONS; - } - if (mesh->mNormals) { - c |= ASSBIN_MESH_HAS_NORMALS; - } - if (mesh->mTangents && mesh->mBitangents) { - c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS; - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++n) { - if (!mesh->mTextureCoords[n]) { - break; - } - c |= ASSBIN_MESH_HAS_TEXCOORD(n); - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS; ++n) { - if (!mesh->mColors[n]) { - break; - } - c |= ASSBIN_MESH_HAS_COLOR(n); - } - Write<unsigned int>(&chunk, c); - - aiVector3D minVec, maxVec; - if (mesh->mVertices) { - if (shortened) { - WriteBounds(&chunk, mesh->mVertices, mesh->mNumVertices); - } // else write as usual - else - WriteArray<aiVector3D>(&chunk, mesh->mVertices, mesh->mNumVertices); - } - if (mesh->mNormals) { - if (shortened) { - WriteBounds(&chunk, mesh->mNormals, mesh->mNumVertices); - } // else write as usual - else - WriteArray<aiVector3D>(&chunk, mesh->mNormals, mesh->mNumVertices); - } - if (mesh->mTangents && mesh->mBitangents) { - if (shortened) { - WriteBounds(&chunk, mesh->mTangents, mesh->mNumVertices); - WriteBounds(&chunk, mesh->mBitangents, mesh->mNumVertices); - } // else write as usual - else { - WriteArray<aiVector3D>(&chunk, mesh->mTangents, mesh->mNumVertices); - WriteArray<aiVector3D>(&chunk, mesh->mBitangents, mesh->mNumVertices); - } - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS; ++n) { - if (!mesh->mColors[n]) - break; - - if (shortened) { - WriteBounds(&chunk, mesh->mColors[n], mesh->mNumVertices); - } // else write as usual - else - WriteArray<aiColor4D>(&chunk, mesh->mColors[n], mesh->mNumVertices); - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++n) { - if (!mesh->mTextureCoords[n]) - break; - - // write number of UV components - Write<unsigned int>(&chunk, mesh->mNumUVComponents[n]); - - if (shortened) { - WriteBounds(&chunk, mesh->mTextureCoords[n], mesh->mNumVertices); - } // else write as usual - else - WriteArray<aiVector3D>(&chunk, mesh->mTextureCoords[n], mesh->mNumVertices); - } - - // write faces. There are no floating-point calculations involved - // in these, so we can write a simple hash over the face data - // to the dump file. We generate a single 32 Bit hash for 512 faces - // using Assimp's standard hashing function. - if (shortened) { - unsigned int processed = 0; - for (unsigned int job; (job = std::min(mesh->mNumFaces - processed, 512u)); processed += job) { - uint32_t hash = 0; - for (unsigned int a = 0; a < job; ++a) { - - const aiFace &f = mesh->mFaces[processed + a]; - uint32_t tmp = f.mNumIndices; - hash = SuperFastHash(reinterpret_cast<const char *>(&tmp), sizeof tmp, hash); - for (unsigned int i = 0; i < f.mNumIndices; ++i) { - static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff"); - tmp = static_cast<uint32_t>(f.mIndices[i]); - hash = SuperFastHash(reinterpret_cast<const char *>(&tmp), sizeof tmp, hash); - } - } - Write<unsigned int>(&chunk, hash); - } - } else // else write as usual - { - // if there are less than 2^16 vertices, we can simply use 16 bit integers ... - for (unsigned int i = 0; i < mesh->mNumFaces; ++i) { - const aiFace &f = mesh->mFaces[i]; - - static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff"); - Write<uint16_t>(&chunk, static_cast<uint16_t>(f.mNumIndices)); - - for (unsigned int a = 0; a < f.mNumIndices; ++a) { - if (mesh->mNumVertices < (1u << 16)) { - Write<uint16_t>(&chunk, static_cast<uint16_t>(f.mIndices[a])); - } else { - Write<unsigned int>(&chunk, f.mIndices[a]); - } - } - } - } - - // write bones - if (mesh->mNumBones) { - for (unsigned int a = 0; a < mesh->mNumBones; ++a) { - const aiBone *b = mesh->mBones[a]; - WriteBinaryBone(&chunk, b); - } - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryMaterialProperty(IOStream *container, const aiMaterialProperty *prop) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIMATERIALPROPERTY); - - Write<aiString>(&chunk, prop->mKey); - Write<unsigned int>(&chunk, prop->mSemantic); - Write<unsigned int>(&chunk, prop->mIndex); - - Write<unsigned int>(&chunk, prop->mDataLength); - Write<unsigned int>(&chunk, (unsigned int)prop->mType); - chunk.Write(prop->mData, 1, prop->mDataLength); - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryMaterial(IOStream *container, const aiMaterial *mat) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIMATERIAL); - - Write<unsigned int>(&chunk, mat->mNumProperties); - for (unsigned int i = 0; i < mat->mNumProperties; ++i) { - WriteBinaryMaterialProperty(&chunk, mat->mProperties[i]); - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryNodeAnim(IOStream *container, const aiNodeAnim *nd) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AINODEANIM); - - Write<aiString>(&chunk, nd->mNodeName); - Write<unsigned int>(&chunk, nd->mNumPositionKeys); - Write<unsigned int>(&chunk, nd->mNumRotationKeys); - Write<unsigned int>(&chunk, nd->mNumScalingKeys); - Write<unsigned int>(&chunk, nd->mPreState); - Write<unsigned int>(&chunk, nd->mPostState); - - if (nd->mPositionKeys) { - if (shortened) { - WriteBounds(&chunk, nd->mPositionKeys, nd->mNumPositionKeys); - - } // else write as usual - else - WriteArray<aiVectorKey>(&chunk, nd->mPositionKeys, nd->mNumPositionKeys); - } - if (nd->mRotationKeys) { - if (shortened) { - WriteBounds(&chunk, nd->mRotationKeys, nd->mNumRotationKeys); - - } // else write as usual - else - WriteArray<aiQuatKey>(&chunk, nd->mRotationKeys, nd->mNumRotationKeys); - } - if (nd->mScalingKeys) { - if (shortened) { - WriteBounds(&chunk, nd->mScalingKeys, nd->mNumScalingKeys); - - } // else write as usual - else - WriteArray<aiVectorKey>(&chunk, nd->mScalingKeys, nd->mNumScalingKeys); - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryAnim(IOStream *container, const aiAnimation *anim) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIANIMATION); - - Write<aiString>(&chunk, anim->mName); - Write<double>(&chunk, anim->mDuration); - Write<double>(&chunk, anim->mTicksPerSecond); - Write<unsigned int>(&chunk, anim->mNumChannels); - - for (unsigned int a = 0; a < anim->mNumChannels; ++a) { - const aiNodeAnim *nd = anim->mChannels[a]; - WriteBinaryNodeAnim(&chunk, nd); - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryLight(IOStream *container, const aiLight *l) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AILIGHT); - - Write<aiString>(&chunk, l->mName); - Write<unsigned int>(&chunk, l->mType); - - if (l->mType != aiLightSource_DIRECTIONAL) { - Write<float>(&chunk, l->mAttenuationConstant); - Write<float>(&chunk, l->mAttenuationLinear); - Write<float>(&chunk, l->mAttenuationQuadratic); - } - - Write<aiColor3D>(&chunk, l->mColorDiffuse); - Write<aiColor3D>(&chunk, l->mColorSpecular); - Write<aiColor3D>(&chunk, l->mColorAmbient); - - if (l->mType == aiLightSource_SPOT) { - Write<float>(&chunk, l->mAngleInnerCone); - Write<float>(&chunk, l->mAngleOuterCone); - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryCamera(IOStream *container, const aiCamera *cam) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AICAMERA); - - Write<aiString>(&chunk, cam->mName); - Write<aiVector3D>(&chunk, cam->mPosition); - Write<aiVector3D>(&chunk, cam->mLookAt); - Write<aiVector3D>(&chunk, cam->mUp); - Write<float>(&chunk, cam->mHorizontalFOV); - Write<float>(&chunk, cam->mClipPlaneNear); - Write<float>(&chunk, cam->mClipPlaneFar); - Write<float>(&chunk, cam->mAspect); - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryScene(IOStream *container, const aiScene *scene) { - AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AISCENE); - - // basic scene information - Write<unsigned int>(&chunk, scene->mFlags); - Write<unsigned int>(&chunk, scene->mNumMeshes); - Write<unsigned int>(&chunk, scene->mNumMaterials); - Write<unsigned int>(&chunk, scene->mNumAnimations); - Write<unsigned int>(&chunk, scene->mNumTextures); - Write<unsigned int>(&chunk, scene->mNumLights); - Write<unsigned int>(&chunk, scene->mNumCameras); - - // write node graph - WriteBinaryNode(&chunk, scene->mRootNode); - - // write all meshes - for (unsigned int i = 0; i < scene->mNumMeshes; ++i) { - const aiMesh *mesh = scene->mMeshes[i]; - WriteBinaryMesh(&chunk, mesh); - } - - // write materials - for (unsigned int i = 0; i < scene->mNumMaterials; ++i) { - const aiMaterial *mat = scene->mMaterials[i]; - WriteBinaryMaterial(&chunk, mat); - } - - // write all animations - for (unsigned int i = 0; i < scene->mNumAnimations; ++i) { - const aiAnimation *anim = scene->mAnimations[i]; - WriteBinaryAnim(&chunk, anim); - } - - // write all textures - for (unsigned int i = 0; i < scene->mNumTextures; ++i) { - const aiTexture *mesh = scene->mTextures[i]; - WriteBinaryTexture(&chunk, mesh); - } - - // write lights - for (unsigned int i = 0; i < scene->mNumLights; ++i) { - const aiLight *l = scene->mLights[i]; - WriteBinaryLight(&chunk, l); - } - - // write cameras - for (unsigned int i = 0; i < scene->mNumCameras; ++i) { - const aiCamera *cam = scene->mCameras[i]; - WriteBinaryCamera(&chunk, cam); - } - } - -public: - AssbinFileWriter(bool shortened, bool compressed) : - shortened(shortened), compressed(compressed) { - } - - // ----------------------------------------------------------------------------------- - // Write a binary model dump - void WriteBinaryDump(const char *pFile, const char *cmd, IOSystem *pIOSystem, const aiScene *pScene) { - IOStream *out = pIOSystem->Open(pFile, "wb"); - if (!out) - throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n'); - - auto CloseIOStream = [&]() { - if (out) { - pIOSystem->Close(out); - out = nullptr; // Ensure this is only done once. - } - }; - - try { - time_t tt = time(nullptr); -#if _WIN32 - tm *p = gmtime(&tt); -#else - struct tm now; - tm *p = gmtime_r(&tt, &now); -#endif - - // header - char s[64]; - memset(s, 0, 64); -#if _MSC_VER >= 1400 - sprintf_s(s, "ASSIMP.binary-dump.%s", asctime(p)); -#else - ai_snprintf(s, 64, "ASSIMP.binary-dump.%s", asctime(p)); -#endif - out->Write(s, 44, 1); - // == 44 bytes - - Write<unsigned int>(out, ASSBIN_VERSION_MAJOR); - Write<unsigned int>(out, ASSBIN_VERSION_MINOR); - Write<unsigned int>(out, aiGetVersionRevision()); - Write<unsigned int>(out, aiGetCompileFlags()); - Write<uint16_t>(out, shortened); - Write<uint16_t>(out, compressed); - // == 20 bytes - - char buff[256] = { 0 }; - ai_snprintf(buff, 256, "%s", pFile); - out->Write(buff, sizeof(char), 256); - - memset(buff, 0, sizeof(buff)); - ai_snprintf(buff, 128, "%s", cmd); - out->Write(buff, sizeof(char), 128); - - // leave 64 bytes free for future extensions - memset(buff, 0xcd, 64); - out->Write(buff, sizeof(char), 64); - // == 435 bytes - - // ==== total header size: 512 bytes - ai_assert(out->Tell() == ASSBIN_HEADER_LENGTH); - - // Up to here the data is uncompressed. For compressed files, the rest - // is compressed using standard DEFLATE from zlib. - if (compressed) { - AssbinChunkWriter uncompressedStream(nullptr, 0); - WriteBinaryScene(&uncompressedStream, pScene); - - uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell()); - uLongf compressedSize = (uLongf)compressBound(uncompressedSize); - uint8_t *compressedBuffer = new uint8_t[compressedSize]; - - int res = compress2(compressedBuffer, &compressedSize, (const Bytef *)uncompressedStream.GetBufferPointer(), uncompressedSize, 9); - if (res != Z_OK) { - delete[] compressedBuffer; - throw DeadlyExportError("Compression failed."); - } - - out->Write(&uncompressedSize, sizeof(uint32_t), 1); - out->Write(compressedBuffer, sizeof(char), compressedSize); - - delete[] compressedBuffer; - } else { - WriteBinaryScene(out, pScene); - } - - CloseIOStream(); - } catch (...) { - CloseIOStream(); - throw; - } - } -}; - -void DumpSceneToAssbin( - const char *pFile, const char *cmd, IOSystem *pIOSystem, - const aiScene *pScene, bool shortened, bool compressed) { - AssbinFileWriter fileWriter(shortened, compressed); - fileWriter.WriteBinaryDump(pFile, cmd, pIOSystem, pScene); -} -#if _MSC_VER -#pragma warning(pop) -#endif // _MSC_VER - -} // end of namespace Assimp diff --git a/libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.h b/libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.h deleted file mode 100644 index cfed3b4..0000000 --- a/libs/assimp/code/AssetLib/Assbin/AssbinFileWriter.h +++ /dev/null @@ -1,65 +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. - ----------------------------------------------------------------------- -*/ - -/** @file AssbinFileWriter.h - * @brief Declaration of Assbin file writer. - */ - -#ifndef AI_ASSBINFILEWRITER_H_INC -#define AI_ASSBINFILEWRITER_H_INC - -#include <assimp/defs.h> -#include <assimp/scene.h> -#include <assimp/IOSystem.hpp> - -namespace Assimp { - -void ASSIMP_API DumpSceneToAssbin( - const char *pFile, - const char *cmd, - IOSystem *pIOSystem, - const aiScene *pScene, - bool shortened, - bool compressed); - -} - -#endif // AI_ASSBINFILEWRITER_H_INC diff --git a/libs/assimp/code/AssetLib/Assbin/AssbinLoader.cpp b/libs/assimp/code/AssetLib/Assbin/AssbinLoader.cpp deleted file mode 100644 index 060ce43..0000000 --- a/libs/assimp/code/AssetLib/Assbin/AssbinLoader.cpp +++ /dev/null @@ -1,730 +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. ---------------------------------------------------------------------------- -*/ - -/** @file AssbinLoader.cpp - * @brief Implementation of the .assbin importer class - * - * see assbin_chunks.h - */ - -#ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER - -// internal headers -#include "AssetLib/Assbin/AssbinLoader.h" -#include "Common/assbin_chunks.h" -#include <assimp/MemoryIOWrapper.h> -#include <assimp/anim.h> -#include <assimp/importerdesc.h> -#include <assimp/mesh.h> -#include <assimp/scene.h> -#include <memory> - -#ifdef ASSIMP_BUILD_NO_OWN_ZLIB -#include <zlib.h> -#else -#include <contrib/zlib/zlib.h> -#endif - -using namespace Assimp; - -static const aiImporterDesc desc = { - "Assimp Binary Importer", - "Gargaj / Conspiracy", - "", - "", - aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour, - 0, - 0, - 0, - 0, - "assbin" -}; - -// ----------------------------------------------------------------------------------- -const aiImporterDesc *AssbinImporter::GetInfo() const { - return &desc; -} - -// ----------------------------------------------------------------------------------- -bool AssbinImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { - IOStream *in = pIOHandler->Open(pFile); - if (nullptr == in) { - return false; - } - - char s[32]; - in->Read(s, sizeof(char), 32); - - pIOHandler->Close(in); - - return strncmp(s, "ASSIMP.binary-dump.", 19) == 0; -} - -// ----------------------------------------------------------------------------------- -template <typename T> -T Read(IOStream *stream) { - T t; - size_t res = stream->Read(&t, sizeof(T), 1); - if (res != 1) { - throw DeadlyImportError("Unexpected EOF"); - } - return t; -} - -// ----------------------------------------------------------------------------------- -template <> -aiVector3D Read<aiVector3D>(IOStream *stream) { - aiVector3D v; - v.x = Read<ai_real>(stream); - v.y = Read<ai_real>(stream); - v.z = Read<ai_real>(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <> -aiColor4D Read<aiColor4D>(IOStream *stream) { - aiColor4D c; - c.r = Read<ai_real>(stream); - c.g = Read<ai_real>(stream); - c.b = Read<ai_real>(stream); - c.a = Read<ai_real>(stream); - return c; -} - -// ----------------------------------------------------------------------------------- -template <> -aiQuaternion Read<aiQuaternion>(IOStream *stream) { - aiQuaternion v; - v.w = Read<ai_real>(stream); - v.x = Read<ai_real>(stream); - v.y = Read<ai_real>(stream); - v.z = Read<ai_real>(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <> -aiString Read<aiString>(IOStream *stream) { - aiString s; - stream->Read(&s.length, 4, 1); - if (s.length) { - stream->Read(s.data, s.length, 1); - } - s.data[s.length] = 0; - - return s; -} - -// ----------------------------------------------------------------------------------- -template <> -aiVertexWeight Read<aiVertexWeight>(IOStream *stream) { - aiVertexWeight w; - w.mVertexId = Read<unsigned int>(stream); - w.mWeight = Read<ai_real>(stream); - return w; -} - -// ----------------------------------------------------------------------------------- -template <> -aiMatrix4x4 Read<aiMatrix4x4>(IOStream *stream) { - aiMatrix4x4 m; - for (unsigned int i = 0; i < 4; ++i) { - for (unsigned int i2 = 0; i2 < 4; ++i2) { - m[i][i2] = Read<ai_real>(stream); - } - } - return m; -} - -// ----------------------------------------------------------------------------------- -template <> -aiVectorKey Read<aiVectorKey>(IOStream *stream) { - aiVectorKey v; - v.mTime = Read<double>(stream); - v.mValue = Read<aiVector3D>(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <> -aiQuatKey Read<aiQuatKey>(IOStream *stream) { - aiQuatKey v; - v.mTime = Read<double>(stream); - v.mValue = Read<aiQuaternion>(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <typename T> -void ReadArray(IOStream *stream, T *out, unsigned int size) { - ai_assert(nullptr != stream); - ai_assert(nullptr != out); - - for (unsigned int i = 0; i < size; i++) { - out[i] = Read<T>(stream); - } -} - -// ----------------------------------------------------------------------------------- -template <typename T> -void ReadBounds(IOStream *stream, T * /*p*/, unsigned int n) { - // not sure what to do here, the data isn't really useful. - stream->Seek(sizeof(T) * n, aiOrigin_CUR); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryNode(IOStream *stream, aiNode **onode, aiNode *parent) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - std::unique_ptr<aiNode> node(new aiNode()); - - node->mName = Read<aiString>(stream); - node->mTransformation = Read<aiMatrix4x4>(stream); - unsigned numChildren = Read<unsigned int>(stream); - unsigned numMeshes = Read<unsigned int>(stream); - unsigned int nb_metadata = Read<unsigned int>(stream); - - if (parent) { - node->mParent = parent; - } - - if (numMeshes) { - node->mMeshes = new unsigned int[numMeshes]; - for (unsigned int i = 0; i < numMeshes; ++i) { - node->mMeshes[i] = Read<unsigned int>(stream); - node->mNumMeshes++; - } - } - - if (numChildren) { - node->mChildren = new aiNode *[numChildren]; - for (unsigned int i = 0; i < numChildren; ++i) { - ReadBinaryNode(stream, &node->mChildren[i], node.get()); - node->mNumChildren++; - } - } - - if (nb_metadata > 0) { - node->mMetaData = aiMetadata::Alloc(nb_metadata); - for (unsigned int i = 0; i < nb_metadata; ++i) { - node->mMetaData->mKeys[i] = Read<aiString>(stream); - node->mMetaData->mValues[i].mType = (aiMetadataType)Read<uint16_t>(stream); - void *data = nullptr; - - switch (node->mMetaData->mValues[i].mType) { - case AI_BOOL: - data = new bool(Read<bool>(stream)); - break; - case AI_INT32: - data = new int32_t(Read<int32_t>(stream)); - break; - case AI_UINT64: - data = new uint64_t(Read<uint64_t>(stream)); - break; - case AI_FLOAT: - data = new ai_real(Read<ai_real>(stream)); - break; - case AI_DOUBLE: - data = new double(Read<double>(stream)); - break; - case AI_AISTRING: - data = new aiString(Read<aiString>(stream)); - break; - case AI_AIVECTOR3D: - data = new aiVector3D(Read<aiVector3D>(stream)); - break; -#ifndef SWIG - case FORCE_32BIT: -#endif // SWIG - default: - break; - } - - node->mMetaData->mValues[i].mData = data; - } - } - *onode = node.release(); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryBone(IOStream *stream, aiBone *b) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIBONE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - b->mName = Read<aiString>(stream); - b->mNumWeights = Read<unsigned int>(stream); - b->mOffsetMatrix = Read<aiMatrix4x4>(stream); - - // for the moment we write dumb min/max values for the bones, too. - // maybe I'll add a better, hash-like solution later - if (shortened) { - ReadBounds(stream, b->mWeights, b->mNumWeights); - } else { - // else write as usual - b->mWeights = new aiVertexWeight[b->mNumWeights]; - ReadArray<aiVertexWeight>(stream, b->mWeights, b->mNumWeights); - } -} - -// ----------------------------------------------------------------------------------- -static bool fitsIntoUI16(unsigned int mNumVertices) { - return (mNumVertices < (1u << 16)); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryMesh(IOStream *stream, aiMesh *mesh) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMESH) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - mesh->mPrimitiveTypes = Read<unsigned int>(stream); - mesh->mNumVertices = Read<unsigned int>(stream); - mesh->mNumFaces = Read<unsigned int>(stream); - mesh->mNumBones = Read<unsigned int>(stream); - mesh->mMaterialIndex = Read<unsigned int>(stream); - - // first of all, write bits for all existent vertex components - unsigned int c = Read<unsigned int>(stream); - - if (c & ASSBIN_MESH_HAS_POSITIONS) { - if (shortened) { - ReadBounds(stream, mesh->mVertices, mesh->mNumVertices); - } else { - // else write as usual - mesh->mVertices = new aiVector3D[mesh->mNumVertices]; - ReadArray<aiVector3D>(stream, mesh->mVertices, mesh->mNumVertices); - } - } - if (c & ASSBIN_MESH_HAS_NORMALS) { - if (shortened) { - ReadBounds(stream, mesh->mNormals, mesh->mNumVertices); - } else { - // else write as usual - mesh->mNormals = new aiVector3D[mesh->mNumVertices]; - ReadArray<aiVector3D>(stream, mesh->mNormals, mesh->mNumVertices); - } - } - if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) { - if (shortened) { - ReadBounds(stream, mesh->mTangents, mesh->mNumVertices); - ReadBounds(stream, mesh->mBitangents, mesh->mNumVertices); - } else { - // else write as usual - mesh->mTangents = new aiVector3D[mesh->mNumVertices]; - ReadArray<aiVector3D>(stream, mesh->mTangents, mesh->mNumVertices); - mesh->mBitangents = new aiVector3D[mesh->mNumVertices]; - ReadArray<aiVector3D>(stream, mesh->mBitangents, mesh->mNumVertices); - } - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS; ++n) { - if (!(c & ASSBIN_MESH_HAS_COLOR(n))) { - break; - } - - if (shortened) { - ReadBounds(stream, mesh->mColors[n], mesh->mNumVertices); - } else { - // else write as usual - mesh->mColors[n] = new aiColor4D[mesh->mNumVertices]; - ReadArray<aiColor4D>(stream, mesh->mColors[n], mesh->mNumVertices); - } - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++n) { - if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n))) { - break; - } - - // write number of UV components - mesh->mNumUVComponents[n] = Read<unsigned int>(stream); - - if (shortened) { - ReadBounds(stream, mesh->mTextureCoords[n], mesh->mNumVertices); - } else { - // else write as usual - mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices]; - ReadArray<aiVector3D>(stream, mesh->mTextureCoords[n], mesh->mNumVertices); - } - } - - // write faces. There are no floating-point calculations involved - // in these, so we can write a simple hash over the face data - // to the dump file. We generate a single 32 Bit hash for 512 faces - // using Assimp's standard hashing function. - if (shortened) { - Read<unsigned int>(stream); - } else { - // else write as usual - // if there are less than 2^16 vertices, we can simply use 16 bit integers ... - mesh->mFaces = new aiFace[mesh->mNumFaces]; - for (unsigned int i = 0; i < mesh->mNumFaces; ++i) { - aiFace &f = mesh->mFaces[i]; - - static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff"); - f.mNumIndices = Read<uint16_t>(stream); - f.mIndices = new unsigned int[f.mNumIndices]; - - for (unsigned int a = 0; a < f.mNumIndices; ++a) { - // Check if unsigned short ( 16 bit ) are big enough for the indices - if (fitsIntoUI16(mesh->mNumVertices)) { - f.mIndices[a] = Read<uint16_t>(stream); - } else { - f.mIndices[a] = Read<unsigned int>(stream); - } - } - } - } - - // write bones - if (mesh->mNumBones) { - mesh->mBones = new C_STRUCT aiBone *[mesh->mNumBones]; - for (unsigned int a = 0; a < mesh->mNumBones; ++a) { - mesh->mBones[a] = new aiBone(); - ReadBinaryBone(stream, mesh->mBones[a]); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryMaterialProperty(IOStream *stream, aiMaterialProperty *prop) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIALPROPERTY) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - prop->mKey = Read<aiString>(stream); - prop->mSemantic = Read<unsigned int>(stream); - prop->mIndex = Read<unsigned int>(stream); - - prop->mDataLength = Read<unsigned int>(stream); - prop->mType = (aiPropertyTypeInfo)Read<unsigned int>(stream); - prop->mData = new char[prop->mDataLength]; - stream->Read(prop->mData, 1, prop->mDataLength); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryMaterial(IOStream *stream, aiMaterial *mat) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIAL) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - mat->mNumAllocated = mat->mNumProperties = Read<unsigned int>(stream); - if (mat->mNumProperties) { - if (mat->mProperties) { - delete[] mat->mProperties; - } - mat->mProperties = new aiMaterialProperty *[mat->mNumProperties]; - for (unsigned int i = 0; i < mat->mNumProperties; ++i) { - mat->mProperties[i] = new aiMaterialProperty(); - ReadBinaryMaterialProperty(stream, mat->mProperties[i]); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryNodeAnim(IOStream *stream, aiNodeAnim *nd) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODEANIM) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - nd->mNodeName = Read<aiString>(stream); - nd->mNumPositionKeys = Read<unsigned int>(stream); - nd->mNumRotationKeys = Read<unsigned int>(stream); - nd->mNumScalingKeys = Read<unsigned int>(stream); - nd->mPreState = (aiAnimBehaviour)Read<unsigned int>(stream); - nd->mPostState = (aiAnimBehaviour)Read<unsigned int>(stream); - - if (nd->mNumPositionKeys) { - if (shortened) { - ReadBounds(stream, nd->mPositionKeys, nd->mNumPositionKeys); - - } // else write as usual - else { - nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys]; - ReadArray<aiVectorKey>(stream, nd->mPositionKeys, nd->mNumPositionKeys); - } - } - if (nd->mNumRotationKeys) { - if (shortened) { - ReadBounds(stream, nd->mRotationKeys, nd->mNumRotationKeys); - - } else { - // else write as usual - nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys]; - ReadArray<aiQuatKey>(stream, nd->mRotationKeys, nd->mNumRotationKeys); - } - } - if (nd->mNumScalingKeys) { - if (shortened) { - ReadBounds(stream, nd->mScalingKeys, nd->mNumScalingKeys); - - } else { - // else write as usual - nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys]; - ReadArray<aiVectorKey>(stream, nd->mScalingKeys, nd->mNumScalingKeys); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryAnim(IOStream *stream, aiAnimation *anim) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIANIMATION) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - anim->mName = Read<aiString>(stream); - anim->mDuration = Read<double>(stream); - anim->mTicksPerSecond = Read<double>(stream); - anim->mNumChannels = Read<unsigned int>(stream); - - if (anim->mNumChannels) { - anim->mChannels = new aiNodeAnim *[anim->mNumChannels]; - for (unsigned int a = 0; a < anim->mNumChannels; ++a) { - anim->mChannels[a] = new aiNodeAnim(); - ReadBinaryNodeAnim(stream, anim->mChannels[a]); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryTexture(IOStream *stream, aiTexture *tex) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AITEXTURE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - tex->mWidth = Read<unsigned int>(stream); - tex->mHeight = Read<unsigned int>(stream); - stream->Read(tex->achFormatHint, sizeof(char), HINTMAXTEXTURELEN - 1); - - if (!shortened) { - if (!tex->mHeight) { - tex->pcData = new aiTexel[tex->mWidth]; - stream->Read(tex->pcData, 1, tex->mWidth); - } else { - tex->pcData = new aiTexel[tex->mWidth * tex->mHeight]; - stream->Read(tex->pcData, 1, tex->mWidth * tex->mHeight * 4); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryLight(IOStream *stream, aiLight *l) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AILIGHT) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - l->mName = Read<aiString>(stream); - l->mType = (aiLightSourceType)Read<unsigned int>(stream); - - if (l->mType != aiLightSource_DIRECTIONAL) { - l->mAttenuationConstant = Read<float>(stream); - l->mAttenuationLinear = Read<float>(stream); - l->mAttenuationQuadratic = Read<float>(stream); - } - - l->mColorDiffuse = Read<aiColor3D>(stream); - l->mColorSpecular = Read<aiColor3D>(stream); - l->mColorAmbient = Read<aiColor3D>(stream); - - if (l->mType == aiLightSource_SPOT) { - l->mAngleInnerCone = Read<float>(stream); - l->mAngleOuterCone = Read<float>(stream); - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryCamera(IOStream *stream, aiCamera *cam) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AICAMERA) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - cam->mName = Read<aiString>(stream); - cam->mPosition = Read<aiVector3D>(stream); - cam->mLookAt = Read<aiVector3D>(stream); - cam->mUp = Read<aiVector3D>(stream); - cam->mHorizontalFOV = Read<float>(stream); - cam->mClipPlaneNear = Read<float>(stream); - cam->mClipPlaneFar = Read<float>(stream); - cam->mAspect = Read<float>(stream); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryScene(IOStream *stream, aiScene *scene) { - if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AISCENE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read<uint32_t>(stream); - - scene->mFlags = Read<unsigned int>(stream); - scene->mNumMeshes = Read<unsigned int>(stream); - scene->mNumMaterials = Read<unsigned int>(stream); - scene->mNumAnimations = Read<unsigned int>(stream); - scene->mNumTextures = Read<unsigned int>(stream); - scene->mNumLights = Read<unsigned int>(stream); - scene->mNumCameras = Read<unsigned int>(stream); - - // Read node graph - //scene->mRootNode = new aiNode[1]; - ReadBinaryNode(stream, &scene->mRootNode, (aiNode *)nullptr); - - // Read all meshes - if (scene->mNumMeshes) { - scene->mMeshes = new aiMesh *[scene->mNumMeshes]; - memset(scene->mMeshes, 0, scene->mNumMeshes * sizeof(aiMesh *)); - for (unsigned int i = 0; i < scene->mNumMeshes; ++i) { - scene->mMeshes[i] = new aiMesh(); - ReadBinaryMesh(stream, scene->mMeshes[i]); - } - } - - // Read materials - if (scene->mNumMaterials) { - scene->mMaterials = new aiMaterial *[scene->mNumMaterials]; - memset(scene->mMaterials, 0, scene->mNumMaterials * sizeof(aiMaterial *)); - for (unsigned int i = 0; i < scene->mNumMaterials; ++i) { - scene->mMaterials[i] = new aiMaterial(); - ReadBinaryMaterial(stream, scene->mMaterials[i]); - } - } - - // Read all animations - if (scene->mNumAnimations) { - scene->mAnimations = new aiAnimation *[scene->mNumAnimations]; - memset(scene->mAnimations, 0, scene->mNumAnimations * sizeof(aiAnimation *)); - for (unsigned int i = 0; i < scene->mNumAnimations; ++i) { - scene->mAnimations[i] = new aiAnimation(); - ReadBinaryAnim(stream, scene->mAnimations[i]); - } - } - - // Read all textures - if (scene->mNumTextures) { - scene->mTextures = new aiTexture *[scene->mNumTextures]; - memset(scene->mTextures, 0, scene->mNumTextures * sizeof(aiTexture *)); - for (unsigned int i = 0; i < scene->mNumTextures; ++i) { - scene->mTextures[i] = new aiTexture(); - ReadBinaryTexture(stream, scene->mTextures[i]); - } - } - - // Read lights - if (scene->mNumLights) { - scene->mLights = new aiLight *[scene->mNumLights]; - memset(scene->mLights, 0, scene->mNumLights * sizeof(aiLight *)); - for (unsigned int i = 0; i < scene->mNumLights; ++i) { - scene->mLights[i] = new aiLight(); - ReadBinaryLight(stream, scene->mLights[i]); - } - } - - // Read cameras - if (scene->mNumCameras) { - scene->mCameras = new aiCamera *[scene->mNumCameras]; - memset(scene->mCameras, 0, scene->mNumCameras * sizeof(aiCamera *)); - for (unsigned int i = 0; i < scene->mNumCameras; ++i) { - scene->mCameras[i] = new aiCamera(); - ReadBinaryCamera(stream, scene->mCameras[i]); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { - IOStream *stream = pIOHandler->Open(pFile, "rb"); - if (nullptr == stream) { - throw DeadlyImportError("ASSBIN: Could not open ", pFile); - } - - // signature - stream->Seek(44, aiOrigin_CUR); - - unsigned int versionMajor = Read<unsigned int>(stream); - unsigned int versionMinor = Read<unsigned int>(stream); - if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) { - throw DeadlyImportError("Invalid version, data format not compatible!"); - } - - /*unsigned int versionRevision =*/Read<unsigned int>(stream); - /*unsigned int compileFlags =*/Read<unsigned int>(stream); - - shortened = Read<uint16_t>(stream) > 0; - compressed = Read<uint16_t>(stream) > 0; - - if (shortened) - throw DeadlyImportError("Shortened binaries are not supported!"); - - stream->Seek(256, aiOrigin_CUR); // original filename - stream->Seek(128, aiOrigin_CUR); // options - stream->Seek(64, aiOrigin_CUR); // padding - - if (compressed) { - uLongf uncompressedSize = Read<uint32_t>(stream); - uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell()); - - unsigned char *compressedData = new unsigned char[compressedSize]; - size_t len = stream->Read(compressedData, 1, compressedSize); - ai_assert(len == compressedSize); - - unsigned char *uncompressedData = new unsigned char[uncompressedSize]; - - int res = uncompress(uncompressedData, &uncompressedSize, compressedData, (uLong)len); - if (res != Z_OK) { - delete[] uncompressedData; - delete[] compressedData; - pIOHandler->Close(stream); - throw DeadlyImportError("Zlib decompression failed."); - } - - MemoryIOStream io(uncompressedData, uncompressedSize); - - ReadBinaryScene(&io, pScene); - - delete[] uncompressedData; - delete[] compressedData; - } else { - ReadBinaryScene(stream, pScene); - } - - pIOHandler->Close(stream); -} - -#endif // !! ASSIMP_BUILD_NO_ASSBIN_IMPORTER diff --git a/libs/assimp/code/AssetLib/Assbin/AssbinLoader.h b/libs/assimp/code/AssetLib/Assbin/AssbinLoader.h deleted file mode 100644 index f922b91..0000000 --- a/libs/assimp/code/AssetLib/Assbin/AssbinLoader.h +++ /dev/null @@ -1,99 +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. - ----------------------------------------------------------------------- -*/ - -/** @file AssbinLoader.h - * @brief .assbin File format loader - */ -#ifndef AI_ASSBINIMPORTER_H_INC -#define AI_ASSBINIMPORTER_H_INC - -#include <assimp/BaseImporter.h> - -struct aiMesh; -struct aiNode; -struct aiBone; -struct aiMaterial; -struct aiMaterialProperty; -struct aiNodeAnim; -struct aiAnimation; -struct aiTexture; -struct aiLight; -struct aiCamera; - -#ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER - -namespace Assimp { - -// --------------------------------------------------------------------------------- -/** Importer class for 3D Studio r3 and r4 3DS files - */ -class AssbinImporter : public BaseImporter -{ -private: - bool shortened; - bool compressed; - -public: - bool CanRead(const std::string& pFile, - IOSystem* pIOHandler, bool checkSig) const override; - const aiImporterDesc* GetInfo() const override; - void InternReadFile( - const std::string& pFile,aiScene* pScene,IOSystem* pIOHandler) override; - void ReadHeader(); - void ReadBinaryScene( IOStream * stream, aiScene* pScene ); - void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent ); - void ReadBinaryMesh( IOStream * stream, aiMesh* mesh ); - void ReadBinaryBone( IOStream * stream, aiBone* bone ); - void ReadBinaryMaterial(IOStream * stream, aiMaterial* mat); - void ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop); - void ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd); - void ReadBinaryAnim( IOStream * stream, aiAnimation* anim ); - void ReadBinaryTexture(IOStream * stream, aiTexture* tex); - void ReadBinaryLight( IOStream * stream, aiLight* l ); - void ReadBinaryCamera( IOStream * stream, aiCamera* cam ); -}; - -} // end of namespace Assimp - -#endif // !! ASSIMP_BUILD_NO_ASSBIN_IMPORTER - -#endif // AI_ASSBINIMPORTER_H_INC |