From 8fb7916a0d0cb007a4c3a4e6a31af58765268ca3 Mon Sep 17 00:00:00 2001 From: sanine Date: Sat, 16 Apr 2022 11:55:54 -0500 Subject: delete src/mesh/assimp-master --- .../code/AssetLib/Assbin/AssbinLoader.cpp | 730 --------------------- 1 file changed, 730 deletions(-) delete mode 100644 src/mesh/assimp-master/code/AssetLib/Assbin/AssbinLoader.cpp (limited to 'src/mesh/assimp-master/code/AssetLib/Assbin/AssbinLoader.cpp') diff --git a/src/mesh/assimp-master/code/AssetLib/Assbin/AssbinLoader.cpp b/src/mesh/assimp-master/code/AssetLib/Assbin/AssbinLoader.cpp deleted file mode 100644 index 060ce43..0000000 --- a/src/mesh/assimp-master/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 -#include -#include -#include -#include -#include - -#ifdef ASSIMP_BUILD_NO_OWN_ZLIB -#include -#else -#include -#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 -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(IOStream *stream) { - aiVector3D v; - v.x = Read(stream); - v.y = Read(stream); - v.z = Read(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <> -aiColor4D Read(IOStream *stream) { - aiColor4D c; - c.r = Read(stream); - c.g = Read(stream); - c.b = Read(stream); - c.a = Read(stream); - return c; -} - -// ----------------------------------------------------------------------------------- -template <> -aiQuaternion Read(IOStream *stream) { - aiQuaternion v; - v.w = Read(stream); - v.x = Read(stream); - v.y = Read(stream); - v.z = Read(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <> -aiString Read(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(IOStream *stream) { - aiVertexWeight w; - w.mVertexId = Read(stream); - w.mWeight = Read(stream); - return w; -} - -// ----------------------------------------------------------------------------------- -template <> -aiMatrix4x4 Read(IOStream *stream) { - aiMatrix4x4 m; - for (unsigned int i = 0; i < 4; ++i) { - for (unsigned int i2 = 0; i2 < 4; ++i2) { - m[i][i2] = Read(stream); - } - } - return m; -} - -// ----------------------------------------------------------------------------------- -template <> -aiVectorKey Read(IOStream *stream) { - aiVectorKey v; - v.mTime = Read(stream); - v.mValue = Read(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template <> -aiQuatKey Read(IOStream *stream) { - aiQuatKey v; - v.mTime = Read(stream); - v.mValue = Read(stream); - return v; -} - -// ----------------------------------------------------------------------------------- -template -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(stream); - } -} - -// ----------------------------------------------------------------------------------- -template -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(stream) != ASSBIN_CHUNK_AINODE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - std::unique_ptr node(new aiNode()); - - node->mName = Read(stream); - node->mTransformation = Read(stream); - unsigned numChildren = Read(stream); - unsigned numMeshes = Read(stream); - unsigned int nb_metadata = Read(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(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(stream); - node->mMetaData->mValues[i].mType = (aiMetadataType)Read(stream); - void *data = nullptr; - - switch (node->mMetaData->mValues[i].mType) { - case AI_BOOL: - data = new bool(Read(stream)); - break; - case AI_INT32: - data = new int32_t(Read(stream)); - break; - case AI_UINT64: - data = new uint64_t(Read(stream)); - break; - case AI_FLOAT: - data = new ai_real(Read(stream)); - break; - case AI_DOUBLE: - data = new double(Read(stream)); - break; - case AI_AISTRING: - data = new aiString(Read(stream)); - break; - case AI_AIVECTOR3D: - data = new aiVector3D(Read(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(stream) != ASSBIN_CHUNK_AIBONE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - b->mName = Read(stream); - b->mNumWeights = Read(stream); - b->mOffsetMatrix = Read(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(stream, b->mWeights, b->mNumWeights); - } -} - -// ----------------------------------------------------------------------------------- -static bool fitsIntoUI16(unsigned int mNumVertices) { - return (mNumVertices < (1u << 16)); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryMesh(IOStream *stream, aiMesh *mesh) { - if (Read(stream) != ASSBIN_CHUNK_AIMESH) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - mesh->mPrimitiveTypes = Read(stream); - mesh->mNumVertices = Read(stream); - mesh->mNumFaces = Read(stream); - mesh->mNumBones = Read(stream); - mesh->mMaterialIndex = Read(stream); - - // first of all, write bits for all existent vertex components - unsigned int c = Read(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(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(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(stream, mesh->mTangents, mesh->mNumVertices); - mesh->mBitangents = new aiVector3D[mesh->mNumVertices]; - ReadArray(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(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(stream); - - if (shortened) { - ReadBounds(stream, mesh->mTextureCoords[n], mesh->mNumVertices); - } else { - // else write as usual - mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices]; - ReadArray(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(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(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(stream); - } else { - f.mIndices[a] = Read(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(stream) != ASSBIN_CHUNK_AIMATERIALPROPERTY) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - prop->mKey = Read(stream); - prop->mSemantic = Read(stream); - prop->mIndex = Read(stream); - - prop->mDataLength = Read(stream); - prop->mType = (aiPropertyTypeInfo)Read(stream); - prop->mData = new char[prop->mDataLength]; - stream->Read(prop->mData, 1, prop->mDataLength); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryMaterial(IOStream *stream, aiMaterial *mat) { - if (Read(stream) != ASSBIN_CHUNK_AIMATERIAL) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - mat->mNumAllocated = mat->mNumProperties = Read(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(stream) != ASSBIN_CHUNK_AINODEANIM) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - nd->mNodeName = Read(stream); - nd->mNumPositionKeys = Read(stream); - nd->mNumRotationKeys = Read(stream); - nd->mNumScalingKeys = Read(stream); - nd->mPreState = (aiAnimBehaviour)Read(stream); - nd->mPostState = (aiAnimBehaviour)Read(stream); - - if (nd->mNumPositionKeys) { - if (shortened) { - ReadBounds(stream, nd->mPositionKeys, nd->mNumPositionKeys); - - } // else write as usual - else { - nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys]; - ReadArray(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(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(stream, nd->mScalingKeys, nd->mNumScalingKeys); - } - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryAnim(IOStream *stream, aiAnimation *anim) { - if (Read(stream) != ASSBIN_CHUNK_AIANIMATION) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - anim->mName = Read(stream); - anim->mDuration = Read(stream); - anim->mTicksPerSecond = Read(stream); - anim->mNumChannels = Read(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(stream) != ASSBIN_CHUNK_AITEXTURE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - tex->mWidth = Read(stream); - tex->mHeight = Read(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(stream) != ASSBIN_CHUNK_AILIGHT) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - l->mName = Read(stream); - l->mType = (aiLightSourceType)Read(stream); - - if (l->mType != aiLightSource_DIRECTIONAL) { - l->mAttenuationConstant = Read(stream); - l->mAttenuationLinear = Read(stream); - l->mAttenuationQuadratic = Read(stream); - } - - l->mColorDiffuse = Read(stream); - l->mColorSpecular = Read(stream); - l->mColorAmbient = Read(stream); - - if (l->mType == aiLightSource_SPOT) { - l->mAngleInnerCone = Read(stream); - l->mAngleOuterCone = Read(stream); - } -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryCamera(IOStream *stream, aiCamera *cam) { - if (Read(stream) != ASSBIN_CHUNK_AICAMERA) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - cam->mName = Read(stream); - cam->mPosition = Read(stream); - cam->mLookAt = Read(stream); - cam->mUp = Read(stream); - cam->mHorizontalFOV = Read(stream); - cam->mClipPlaneNear = Read(stream); - cam->mClipPlaneFar = Read(stream); - cam->mAspect = Read(stream); -} - -// ----------------------------------------------------------------------------------- -void AssbinImporter::ReadBinaryScene(IOStream *stream, aiScene *scene) { - if (Read(stream) != ASSBIN_CHUNK_AISCENE) - throw DeadlyImportError("Magic chunk identifiers are wrong!"); - /*uint32_t size =*/Read(stream); - - scene->mFlags = Read(stream); - scene->mNumMeshes = Read(stream); - scene->mNumMaterials = Read(stream); - scene->mNumAnimations = Read(stream); - scene->mNumTextures = Read(stream); - scene->mNumLights = Read(stream); - scene->mNumCameras = Read(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(stream); - unsigned int versionMinor = Read(stream); - if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) { - throw DeadlyImportError("Invalid version, data format not compatible!"); - } - - /*unsigned int versionRevision =*/Read(stream); - /*unsigned int compileFlags =*/Read(stream); - - shortened = Read(stream) > 0; - compressed = Read(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(stream); - uLongf compressedSize = static_cast(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 -- cgit v1.2.1