delete src/mesh/assimp-master

1 files changed, 0 insertions, 730 deletions

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 <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