diff --git a/D3D11Engine/include/assimp/AssertHandler.h b/D3D11Engine/include/assimp/AssertHandler.h
new file mode 100644
index 00000000..1247ff49
--- /dev/null
+++ b/D3D11Engine/include/assimp/AssertHandler.h
@@ -0,0 +1,79 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 Provides facilities to replace the default assert handler. */
+
+#ifndef INCLUDED_AI_ASSERTHANDLER_H
+#define INCLUDED_AI_ASSERTHANDLER_H
+
+#include <assimp/ai_assert.h>
+#include <assimp/defs.h>
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/**
+ *  @brief  Signature of functions which handle assert violations.
+ */
+using AiAssertHandler = void (*)(const char* failedExpression, const char* file, int line);
+
+// ---------------------------------------------------------------------------
+/**
+ *  @brief  Set the assert handler.
+ */
+ASSIMP_API void setAiAssertHandler(AiAssertHandler handler);
+
+// ---------------------------------------------------------------------------
+/** The assert handler which is set by default.
+ *
+ *  @brief  This issues a message to stderr and calls abort.
+ */
+AI_WONT_RETURN ASSIMP_API void defaultAiAssertHandler(const char* failedExpression, const char* file, int line) AI_WONT_RETURN_SUFFIX;
+
+// ---------------------------------------------------------------------------
+/**
+ *  @brief  Dispatches an assert violation to the assert handler.
+ */
+ASSIMP_API void aiAssertViolation(const char* failedExpression, const char* file, int line);
+
+} // end of namespace Assimp
+
+#endif // INCLUDED_AI_ASSERTHANDLER_H
diff --git a/D3D11Engine/include/assimp/Base64.hpp b/D3D11Engine/include/assimp/Base64.hpp
new file mode 100644
index 00000000..10288713
--- /dev/null
+++ b/D3D11Engine/include/assimp/Base64.hpp
@@ -0,0 +1,92 @@
+/*
+---------------------------------------------------------------------------
+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.
+---------------------------------------------------------------------------
+*/
+
+#pragma once
+#ifndef AI_BASE64_HPP_INC
+#define AI_BASE64_HPP_INC
+
+#include <assimp/defs.h>
+
+#include <stdint.h>
+#include <vector>
+#include <string>
+
+namespace Assimp {
+namespace Base64 {
+
+/// @brief Will encode the given character buffer from UTF64 to ASCII
+/// @param in           The UTF-64 buffer.
+/// @param inLength     The size of the buffer
+/// @param out          The encoded ASCII string.
+ASSIMP_API void Encode(const uint8_t *in, size_t inLength, std::string &out);
+
+/// @brief Will encode the given character buffer from UTF64 to ASCII.
+/// @param in   A vector, which contains the buffer for encoding.
+/// @param out  The encoded ASCII string.
+ASSIMP_API void Encode(const std::vector<uint8_t> &in, std::string &out);
+
+/// @brief Will encode the given character buffer from UTF64 to ASCII.
+/// @param in   A vector, which contains the buffer for encoding.
+/// @return The encoded ASCII string.
+ASSIMP_API std::string Encode(const std::vector<uint8_t> &in);
+
+/// @brief Will decode the given character buffer from ASCII to UTF64.
+/// @param in           The ASCII buffer to decode.
+/// @param inLength     The size of the buffer.
+/// @param out          The decoded buffer.
+/// @return The new buffer size.
+ASSIMP_API size_t Decode(const char *in, size_t inLength, uint8_t *&out);
+
+/// @brief Will decode the given character buffer from ASCII to UTF64.
+/// @param in   The ASCII buffer to decode as a std::string.
+/// @param out  The decoded buffer.
+/// @return The new buffer size.
+ASSIMP_API size_t Decode(const std::string &in, std::vector<uint8_t> &out);
+
+/// @brief Will decode the given character buffer from ASCII to UTF64.
+/// @param in   The ASCII string.
+/// @return The decoded buffer in a vector.
+ASSIMP_API std::vector<uint8_t> Decode(const std::string &in);
+
+} // namespace Base64
+} // namespace Assimp
+
+#endif // AI_BASE64_HPP_INC
diff --git a/D3D11Engine/include/assimp/BaseImporter.h b/D3D11Engine/include/assimp/BaseImporter.h
index 656e0f16..d0b17317 100644
--- a/D3D11Engine/include/assimp/BaseImporter.h
+++ b/D3D11Engine/include/assimp/BaseImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/types.h>
 #include <assimp/ProgressHandler.hpp>
+#include <exception>
 #include <set>
 #include <vector>
 #include <memory>
@@ -95,20 +96,15 @@ class ASSIMP_API BaseImporter {
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      *
-     * The implementation should be as quick as possible. A check for
-     * the file extension is enough. If no suitable loader is found with
-     * this strategy, CanRead() is called again, the 'checkSig' parameter
-     * set to true this time. Now the implementation is expected to
-     * perform a full check of the file structure, possibly searching the
-     * first bytes of the file for magic identifiers or keywords.
+     * The implementation is expected to perform a full check of the file
+     * structure, possibly searching the first bytes of the file for magic
+     * identifiers or keywords.
      *
      * @param pFile Path and file name of the file to be examined.
      * @param pIOHandler The IO handler to use for accessing any file.
-     * @param checkSig Set to true if this method is called a second time.
-     *   This time, the implementation may take more time to examine the
-     *   contents of the file to be loaded for magic bytes, keywords, etc
-     *   to be able to load files with unknown/not existent file extensions.
-     * @return true if the class can read this file, false if not.
+     * @param checkSig Legacy; do not use.
+     * @return true if the class can read this file, false if not or if
+     * unsure.
      */
     virtual bool CanRead(
             const std::string &pFile,
@@ -259,11 +255,11 @@ class ASSIMP_API BaseImporter {
     static bool SearchFileHeaderForToken(
             IOSystem *pIOSystem,
             const std::string &file,
-            const char * const *tokens,
-            unsigned int numTokens,
+            const char **tokens,
+            std::size_t numTokens,
             unsigned int searchBytes = 200,
             bool tokensSol = false,
-            bool noAlphaBeforeTokens = false);
+            bool noGraphBeforeTokens = false);
 
     // -------------------------------------------------------------------
     /** @brief Check whether a file has a specific file extension
@@ -279,6 +275,16 @@ class ASSIMP_API BaseImporter {
             const char *ext1 = nullptr,
             const char *ext2 = nullptr);
 
+    // -------------------------------------------------------------------
+    /** @brief Check whether a file has one of the passed file extensions
+     *  @param pFile Input file
+     *  @param extensions Extensions to check for. Lowercase characters only, no dot!
+     *  @note Case-insensitive
+     */
+    static bool HasExtension(
+            const std::string &pFile,
+            const std::set<std::string> &extensions);
+
     // -------------------------------------------------------------------
     /** @brief Extract file extension from a string
      *  @param pFile Input file
@@ -305,7 +311,7 @@ class ASSIMP_API BaseImporter {
             IOSystem *pIOHandler,
             const std::string &pFile,
             const void *magic,
-            unsigned int num,
+            std::size_t num,
             unsigned int offset = 0,
             unsigned int size = 4);
 
diff --git a/D3D11Engine/include/assimp/Bitmap.h b/D3D11Engine/include/assimp/Bitmap.h
index 228f6e9b..2678b5f6 100644
--- a/D3D11Engine/include/assimp/Bitmap.h
+++ b/D3D11Engine/include/assimp/Bitmap.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -63,7 +63,7 @@ namespace Assimp {
 class IOStream;
 
 // ---------------------------------------------------------------------------
-/** 
+/**
  *  This class is used to store and write bitmap information.
  */
 class ASSIMP_API Bitmap {
@@ -78,11 +78,11 @@ class ASSIMP_API Bitmap {
 
         // We define the struct size because sizeof(Header) might return a wrong result because of structure padding.
         static constexpr std::size_t header_size =
-            sizeof(type) +
-            sizeof(size) +
-            sizeof(reserved1) +
-            sizeof(reserved2) +
-            sizeof(offset);
+            sizeof(uint16_t) +
+            sizeof(uint32_t) +
+            sizeof(uint16_t) +
+            sizeof(uint16_t) +
+            sizeof(uint32_t);
     };
 
     struct DIB {
@@ -100,17 +100,17 @@ class ASSIMP_API Bitmap {
 
         // We define the struct size because sizeof(DIB) might return a wrong result because of structure padding.
         static constexpr std::size_t dib_size =
-            sizeof(size) +
-            sizeof(width) +
-            sizeof(height) +
-            sizeof(planes) +
-            sizeof(bits_per_pixel) +
-            sizeof(compression) +
-            sizeof(image_size) +
-            sizeof(x_resolution) +
-            sizeof(y_resolution) +
-            sizeof(nb_colors) +
-            sizeof(nb_important_colors);
+            sizeof(uint32_t) +
+            sizeof(int32_t) +
+            sizeof(int32_t) +
+            sizeof(uint16_t) +
+            sizeof(uint16_t) +
+            sizeof(uint32_t) +
+            sizeof(uint32_t) +
+            sizeof(int32_t) +
+            sizeof(int32_t) +
+            sizeof(uint32_t) +
+            sizeof(uint32_t);
     };
 
     static constexpr std::size_t mBytesPerPixel = 4;
diff --git a/D3D11Engine/include/assimp/BlobIOSystem.h b/D3D11Engine/include/assimp/BlobIOSystem.h
index da220b69..7e8d46a5 100644
--- a/D3D11Engine/include/assimp/BlobIOSystem.h
+++ b/D3D11Engine/include/assimp/BlobIOSystem.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/ByteSwapper.h b/D3D11Engine/include/assimp/ByteSwapper.h
index 94df04b7..488f7a51 100644
--- a/D3D11Engine/include/assimp/ByteSwapper.h
+++ b/D3D11Engine/include/assimp/ByteSwapper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -211,7 +211,7 @@ template <typename T> struct ByteSwap::_swapper<T,8> {
 // --------------------------------------------------------------------------------------
 #if (defined AI_BUILD_BIG_ENDIAN)
 #   define AI_LE(t) (t)
-#   define AI_BE(t) ByteSwap::Swapped(t)
+#   define AI_BE(t) Assimp::ByteSwap::Swapped(t)
 #   define AI_LSWAP2(p)
 #   define AI_LSWAP4(p)
 #   define AI_LSWAP8(p)
@@ -219,16 +219,16 @@ template <typename T> struct ByteSwap::_swapper<T,8> {
 #   define AI_LSWAP4P(p)
 #   define AI_LSWAP8P(p)
 #   define LE_NCONST const
-#   define AI_SWAP2(p) ByteSwap::Swap2(&(p))
-#   define AI_SWAP4(p) ByteSwap::Swap4(&(p))
-#   define AI_SWAP8(p) ByteSwap::Swap8(&(p))
-#   define AI_SWAP2P(p) ByteSwap::Swap2((p))
-#   define AI_SWAP4P(p) ByteSwap::Swap4((p))
-#   define AI_SWAP8P(p) ByteSwap::Swap8((p))
+#   define AI_SWAP2(p) Assimp::ByteSwap::Swap2(&(p))
+#   define AI_SWAP4(p) Assimp::ByteSwap::Swap4(&(p))
+#   define AI_SWAP8(p) Assimp::ByteSwap::Swap8(&(p))
+#   define AI_SWAP2P(p) Assimp::ByteSwap::Swap2((p))
+#   define AI_SWAP4P(p) Assimp::ByteSwap::Swap4((p))
+#   define AI_SWAP8P(p) Assimp::ByteSwap::Swap8((p))
 #   define BE_NCONST
 #else
 #   define AI_BE(t) (t)
-#   define AI_LE(t) ByteSwap::Swapped(t)
+#   define AI_LE(t) Assimp::ByteSwap::Swapped(t)
 #   define AI_SWAP2(p)
 #   define AI_SWAP4(p)
 #   define AI_SWAP8(p)
@@ -236,12 +236,12 @@ template <typename T> struct ByteSwap::_swapper<T,8> {
 #   define AI_SWAP4P(p)
 #   define AI_SWAP8P(p)
 #   define BE_NCONST const
-#   define AI_LSWAP2(p)     ByteSwap::Swap2(&(p))
-#   define AI_LSWAP4(p)     ByteSwap::Swap4(&(p))
-#   define AI_LSWAP8(p)     ByteSwap::Swap8(&(p))
-#   define AI_LSWAP2P(p)    ByteSwap::Swap2((p))
-#   define AI_LSWAP4P(p)    ByteSwap::Swap4((p))
-#   define AI_LSWAP8P(p)    ByteSwap::Swap8((p))
+#   define AI_LSWAP2(p)     Assimp::ByteSwap::Swap2(&(p))
+#   define AI_LSWAP4(p)     Assimp::ByteSwap::Swap4(&(p))
+#   define AI_LSWAP8(p)     Assimp::ByteSwap::Swap8(&(p))
+#   define AI_LSWAP2P(p)    Assimp::ByteSwap::Swap2((p))
+#   define AI_LSWAP4P(p)    Assimp::ByteSwap::Swap4((p))
+#   define AI_LSWAP8P(p)    Assimp::ByteSwap::Swap8((p))
 #   define LE_NCONST
 #endif
 
diff --git a/D3D11Engine/include/assimp/ColladaMetaData.h b/D3D11Engine/include/assimp/ColladaMetaData.h
index de5963b3..52eb3c50 100644
--- a/D3D11Engine/include/assimp/ColladaMetaData.h
+++ b/D3D11Engine/include/assimp/ColladaMetaData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/CreateAnimMesh.h b/D3D11Engine/include/assimp/CreateAnimMesh.h
index 868a1f39..e5211f50 100644
--- a/D3D11Engine/include/assimp/CreateAnimMesh.h
+++ b/D3D11Engine/include/assimp/CreateAnimMesh.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/DefaultIOStream.h b/D3D11Engine/include/assimp/DefaultIOStream.h
index 9e0a4862..67cba3c5 100644
--- a/D3D11Engine/include/assimp/DefaultIOStream.h
+++ b/D3D11Engine/include/assimp/DefaultIOStream.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -74,7 +74,7 @@ class ASSIMP_API DefaultIOStream : public IOStream {
 #endif // __ANDROID__
 
 protected:
-    /// @brief 
+    /// @brief
     DefaultIOStream() AI_NO_EXCEPT;
 
     /// @brief The class constructor with the file name and the stream.
@@ -84,7 +84,7 @@ class ASSIMP_API DefaultIOStream : public IOStream {
 
 public:
     /** Destructor public to allow simple deletion to close the file. */
-    ~DefaultIOStream ();
+    ~DefaultIOStream () override;
 
     // -------------------------------------------------------------------
     /// Read from stream
diff --git a/D3D11Engine/include/assimp/DefaultIOSystem.h b/D3D11Engine/include/assimp/DefaultIOSystem.h
index 2e5d0aac..8545e75c 100644
--- a/D3D11Engine/include/assimp/DefaultIOSystem.h
+++ b/D3D11Engine/include/assimp/DefaultIOSystem.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/DefaultLogger.hpp b/D3D11Engine/include/assimp/DefaultLogger.hpp
index a83aedbd..723097ff 100644
--- a/D3D11Engine/include/assimp/DefaultLogger.hpp
+++ b/D3D11Engine/include/assimp/DefaultLogger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/Exceptional.h b/D3D11Engine/include/assimp/Exceptional.h
index 3078de9f..ec3d38c5 100644
--- a/D3D11Engine/include/assimp/Exceptional.h
+++ b/D3D11Engine/include/assimp/Exceptional.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -98,10 +98,6 @@ class ASSIMP_API DeadlyImportError : public DeadlyErrorBase {
             DeadlyErrorBase(Assimp::Formatter::format(), std::forward<T>(args)...) {
         // empty
     }
-
-#if defined(_MSC_VER) && defined(__clang__)
-    DeadlyImportError(DeadlyImportError& other) = delete;
-#endif
 };
 
 // ---------------------------------------------------------------------------
@@ -114,10 +110,6 @@ class ASSIMP_API DeadlyExportError : public DeadlyErrorBase {
     template<typename... T>
     explicit DeadlyExportError(T&&... args) :
             DeadlyErrorBase(Assimp::Formatter::format(), std::forward<T>(args)...) {}
-
-#if defined(_MSC_VER) && defined(__clang__)
-    DeadlyExportError(DeadlyExportError& other) = delete;
-#endif
 };
 
 #ifdef _MSC_VER
diff --git a/D3D11Engine/include/assimp/Exporter.hpp b/D3D11Engine/include/assimp/Exporter.hpp
index 6ab35a8f..09a45944 100644
--- a/D3D11Engine/include/assimp/Exporter.hpp
+++ b/D3D11Engine/include/assimp/Exporter.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/GenericProperty.h b/D3D11Engine/include/assimp/GenericProperty.h
index cac6ba96..073d5331 100644
--- a/D3D11Engine/include/assimp/GenericProperty.h
+++ b/D3D11Engine/include/assimp/GenericProperty.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/GltfMaterial.h b/D3D11Engine/include/assimp/GltfMaterial.h
index 85476ba0..86ca8897 100644
--- a/D3D11Engine/include/assimp/GltfMaterial.h
+++ b/D3D11Engine/include/assimp/GltfMaterial.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/Hash.h b/D3D11Engine/include/assimp/Hash.h
index 87f06450..cf889362 100644
--- a/D3D11Engine/include/assimp/Hash.h
+++ b/D3D11Engine/include/assimp/Hash.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,7 +47,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
+#include <cmath>
 
 // ------------------------------------------------------------------------------------------------
 // Hashing function taken from
@@ -64,21 +65,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #undef get16bits
 #if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
   || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
-#define get16bits(d) (*((const uint16_t *) (d)))
+#  define get16bits(d) (*((const uint16_t *) (d)))
 #endif
 
 #if !defined (get16bits)
-#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
+#  define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
                        +(uint32_t)(((const uint8_t *)(d))[0]) )
 #endif
 
 // ------------------------------------------------------------------------------------------------
 inline uint32_t SuperFastHash (const char * data, uint32_t len = 0, uint32_t hash = 0) {
-uint32_t tmp;
-int rem;
+    uint32_t tmp;
+    int rem;
 
-    if (!data) return 0;
-    if (!len)len = (uint32_t)::strlen(data);
+    if (data == NULL) return 0;
+    if (len == 0)len = (uint32_t)::strlen(data);
 
     rem = len & 3;
     len >>= 2;
@@ -96,7 +97,7 @@ int rem;
     switch (rem) {
         case 3: hash += get16bits (data);
                 hash ^= hash << 16;
-                hash ^= data[sizeof (uint16_t)] << 18;
+                hash ^= abs(data[sizeof(uint16_t)]) << 18;
                 hash += hash >> 11;
                 break;
         case 2: hash += get16bits (data);
diff --git a/D3D11Engine/include/assimp/IOStream.hpp b/D3D11Engine/include/assimp/IOStream.hpp
index bbf3537b..12beb0db 100644
--- a/D3D11Engine/include/assimp/IOStream.hpp
+++ b/D3D11Engine/include/assimp/IOStream.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -128,15 +128,11 @@ class ASSIMP_API IOStream
 
 // ----------------------------------------------------------------------------------
 AI_FORCE_INLINE
-IOStream::IOStream() AI_NO_EXCEPT {
-    // empty
-}
+IOStream::IOStream() AI_NO_EXCEPT = default;
 
 // ----------------------------------------------------------------------------------
 AI_FORCE_INLINE
-IOStream::~IOStream() {
-    // empty
-}
+IOStream::~IOStream() = default;
 // ----------------------------------------------------------------------------------
 
 } //!namespace Assimp
diff --git a/D3D11Engine/include/assimp/IOStreamBuffer.h b/D3D11Engine/include/assimp/IOStreamBuffer.h
index bbb5ef25..fae480e7 100644
--- a/D3D11Engine/include/assimp/IOStreamBuffer.h
+++ b/D3D11Engine/include/assimp/IOStreamBuffer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -141,9 +141,7 @@ AI_FORCE_INLINE IOStreamBuffer<T>::IOStreamBuffer(size_t cache) :
 }
 
 template <class T>
-AI_FORCE_INLINE IOStreamBuffer<T>::~IOStreamBuffer() {
-    // empty
-}
+AI_FORCE_INLINE IOStreamBuffer<T>::~IOStreamBuffer() = default;
 
 template <class T>
 AI_FORCE_INLINE bool IOStreamBuffer<T>::open(IOStream *stream) {
@@ -325,7 +323,9 @@ AI_FORCE_INLINE bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
         }
     }
     buffer[i] = '\n';
-    ++m_cachePos;
+    while (m_cachePos < m_cacheSize && (m_cache[m_cachePos] == '\r' || m_cache[m_cachePos] == '\n')) {
+        ++m_cachePos;
+    }
 
     return true;
 }
diff --git a/D3D11Engine/include/assimp/IOSystem.hpp b/D3D11Engine/include/assimp/IOSystem.hpp
index dda0718e..30f48b81 100644
--- a/D3D11Engine/include/assimp/IOSystem.hpp
+++ b/D3D11Engine/include/assimp/IOSystem.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -237,15 +237,10 @@ class ASSIMP_API IOSystem
 };
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE IOSystem::IOSystem() AI_NO_EXCEPT :
-        m_pathStack() {
-    // empty
-}
+AI_FORCE_INLINE IOSystem::IOSystem() AI_NO_EXCEPT = default;
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE IOSystem::~IOSystem() {
-    // empty
-}
+AI_FORCE_INLINE IOSystem::~IOSystem() = default;
 
 // ----------------------------------------------------------------------------
 // For compatibility, the interface of some functions taking a std::string was
@@ -288,15 +283,6 @@ AI_FORCE_INLINE bool IOSystem::PushDirectory( const std::string &path ) {
     return true;
 }
 
-// ----------------------------------------------------------------------------
-AI_FORCE_INLINE const std::string &IOSystem::CurrentDirectory() const {
-    if ( m_pathStack.empty() ) {
-        static const std::string Dummy;
-        return Dummy;
-    }
-    return m_pathStack[ m_pathStack.size()-1 ];
-}
-
 // ----------------------------------------------------------------------------
 AI_FORCE_INLINE size_t IOSystem::StackSize() const {
     return m_pathStack.size();
diff --git a/D3D11Engine/include/assimp/Importer.hpp b/D3D11Engine/include/assimp/Importer.hpp
index 6ce327c4..418643f1 100644
--- a/D3D11Engine/include/assimp/Importer.hpp
+++ b/D3D11Engine/include/assimp/Importer.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -113,7 +113,7 @@ namespace Assimp {
 * If you need the Importer to do custom file handling to access the files,
 * implement IOSystem and IOStream and supply an instance of your custom
 * IOSystem implementation by calling SetIOHandler() before calling ReadFile().
-* If you do not assign a custion IO handler, a default handler using the
+* If you do not assign a custom IO handler, a default handler using the
 * standard C++ IO logic will be used.
 *
 * @note One Importer instance is not thread-safe. If you use multiple
diff --git a/D3D11Engine/include/assimp/LineSplitter.h b/D3D11Engine/include/assimp/LineSplitter.h
index 0a9d2443..379821f0 100644
--- a/D3D11Engine/include/assimp/LineSplitter.h
+++ b/D3D11Engine/include/assimp/LineSplitter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -145,7 +145,6 @@ class LineSplitter {
 
 AI_FORCE_INLINE LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim ) :
         mIdx(0),
-        mCur(),
         mStream(stream),
         mSwallow(),
         mSkip_empty_lines(skip_empty_lines),
@@ -155,9 +154,7 @@ AI_FORCE_INLINE LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_emp
     mIdx = 0;
 }
 
-AI_FORCE_INLINE LineSplitter::~LineSplitter() {
-    // empty
-}
+AI_FORCE_INLINE LineSplitter::~LineSplitter() = default;
 
 AI_FORCE_INLINE LineSplitter& LineSplitter::operator++() {
     if (mSwallow) {
diff --git a/D3D11Engine/include/assimp/LogAux.h b/D3D11Engine/include/assimp/LogAux.h
index 01a7d637..a8cb8f24 100644
--- a/D3D11Engine/include/assimp/LogAux.h
+++ b/D3D11Engine/include/assimp/LogAux.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 /// @brief Logger class, which will extend the class by log-functions.
-/// @tparam TDeriving 
+/// @tparam TDeriving
 template<class TDeriving>
 class LogFunctions {
 public:
diff --git a/D3D11Engine/include/assimp/LogStream.hpp b/D3D11Engine/include/assimp/LogStream.hpp
index 64a7955f..3b17b200 100644
--- a/D3D11Engine/include/assimp/LogStream.hpp
+++ b/D3D11Engine/include/assimp/LogStream.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -99,13 +99,9 @@ class ASSIMP_API LogStream
 
 }; // !class LogStream
 
-inline LogStream::LogStream() AI_NO_EXCEPT {
-    // empty
-}
+inline LogStream::LogStream() AI_NO_EXCEPT = default;
 
-inline LogStream::~LogStream() {
-    // empty
-}
+inline LogStream::~LogStream() = default;
 
 } // Namespace Assimp
 
diff --git a/D3D11Engine/include/assimp/Logger.hpp b/D3D11Engine/include/assimp/Logger.hpp
index 549b0fbc..e8df64dd 100644
--- a/D3D11Engine/include/assimp/Logger.hpp
+++ b/D3D11Engine/include/assimp/Logger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -263,9 +263,7 @@ inline Logger::Logger() AI_NO_EXCEPT :
 }
 
 // ----------------------------------------------------------------------------------
-inline Logger::~Logger() {
-    // empty
-}
+inline Logger::~Logger() = default;
 
 // ----------------------------------------------------------------------------------
 inline Logger::Logger(LogSeverity severity) :
diff --git a/D3D11Engine/include/assimp/MathFunctions.h b/D3D11Engine/include/assimp/MathFunctions.h
index 2088c394..f2a7ccdf 100644
--- a/D3D11Engine/include/assimp/MathFunctions.h
+++ b/D3D11Engine/include/assimp/MathFunctions.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/MemoryIOWrapper.h b/D3D11Engine/include/assimp/MemoryIOWrapper.h
index 0e509d99..4023f752 100644
--- a/D3D11Engine/include/assimp/MemoryIOWrapper.h
+++ b/D3D11Engine/include/assimp/MemoryIOWrapper.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -66,23 +65,21 @@ namespace Assimp    {
 // ----------------------------------------------------------------------------------
 class MemoryIOStream : public IOStream {
 public:
-    MemoryIOStream (const uint8_t* buff, size_t len, bool own = false)
-    : buffer (buff)
-    , length(len)
-    , pos((size_t)0)
-    , own(own) {
+    MemoryIOStream (const uint8_t* buff, size_t len, bool own = false) :
+            buffer (buff),
+            length(len),
+            pos(static_cast<size_t>(0)),
+            own(own) {
         // empty
     }
 
-    ~MemoryIOStream ()  {
+    ~MemoryIOStream() override  {
         if(own) {
             delete[] buffer;
         }
     }
 
-    // -------------------------------------------------------------------
-    // Read from stream
-    size_t Read(void* pvBuffer, size_t pSize, size_t pCount)    {
+    size_t Read(void* pvBuffer, size_t pSize, size_t pCount) override {
         ai_assert(nullptr != pvBuffer);
         ai_assert(0 != pSize);
 
@@ -95,16 +92,12 @@ class MemoryIOStream : public IOStream {
         return cnt;
     }
 
-    // -------------------------------------------------------------------
-    // Write to stream
-    size_t Write(const void* /*pvBuffer*/, size_t /*pSize*/,size_t /*pCount*/)  {
+    size_t Write(const void*, size_t, size_t ) override {
         ai_assert(false); // won't be needed
         return 0;
     }
 
-    // -------------------------------------------------------------------
-    // Seek specific position
-    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) {
+    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override {
         if (aiOrigin_SET == pOrigin) {
             if (pOffset > length) {
                 return AI_FAILURE;
@@ -124,21 +117,15 @@ class MemoryIOStream : public IOStream {
         return AI_SUCCESS;
     }
 
-    // -------------------------------------------------------------------
-    // Get current seek position
-    size_t Tell() const {
+    size_t Tell() const override {
         return pos;
     }
 
-    // -------------------------------------------------------------------
-    // Get size of file
-    size_t FileSize() const {
+    size_t FileSize() const override {
         return length;
     }
 
-    // -------------------------------------------------------------------
-    // Flush file contents
-    void Flush() {
+    void Flush() override{
         ai_assert(false); // won't be needed
     }
 
@@ -149,24 +136,19 @@ class MemoryIOStream : public IOStream {
 };
 
 // ---------------------------------------------------------------------------
-/** Dummy IO system to read from a memory buffer */
+/// @brief Dummy IO system to read from a memory buffer.
 class MemoryIOSystem : public IOSystem {
 public:
-    /** Constructor. */
-    MemoryIOSystem(const uint8_t* buff, size_t len, IOSystem* io)
-    : buffer(buff)
-    , length(len)
-    , existing_io(io)
-    , created_streams() {
+    /// @brief Constructor.
+    MemoryIOSystem(const uint8_t* buff, size_t len, IOSystem* io) : buffer(buff), length(len), existing_io(io) {
         // empty
     }
 
-    /** Destructor. */
-    ~MemoryIOSystem() {
-    }
+    /// @brief Destructor.
+    ~MemoryIOSystem() override = default;
 
     // -------------------------------------------------------------------
-    /** Tests for the existence of a file at the given path. */
+    /// @brief Tests for the existence of a file at the given path.
     bool Exists(const char* pFile) const override {
         if (0 == strncmp( pFile, AI_MEMORYIO_MAGIC_FILENAME, AI_MEMORYIO_MAGIC_FILENAME_LENGTH ) ) {
             return true;
@@ -175,24 +157,24 @@ class MemoryIOSystem : public IOSystem {
     }
 
     // -------------------------------------------------------------------
-    /** Returns the directory separator. */
+    /// @brief Returns the directory separator.
     char getOsSeparator() const override {
         return existing_io ? existing_io->getOsSeparator()
                            : '/';  // why not? it doesn't care
     }
 
     // -------------------------------------------------------------------
-    /** Open a new file with a given path. */
+    /// @brief Open a new file with a given path.
     IOStream* Open(const char* pFile, const char* pMode = "rb") override {
         if ( 0 == strncmp( pFile, AI_MEMORYIO_MAGIC_FILENAME, AI_MEMORYIO_MAGIC_FILENAME_LENGTH ) ) {
             created_streams.emplace_back(new MemoryIOStream(buffer, length));
             return created_streams.back();
         }
-        return existing_io ? existing_io->Open(pFile, pMode) : NULL;
+        return existing_io ? existing_io->Open(pFile, pMode) : nullptr;
     }
 
     // -------------------------------------------------------------------
-    /** Closes the given file and releases all resources associated with it. */
+    /// @brief Closes the given file and releases all resources associated with it.
     void Close( IOStream* pFile) override {
         auto it = std::find(created_streams.begin(), created_streams.end(), pFile);
         if (it != created_streams.end()) {
@@ -204,36 +186,43 @@ class MemoryIOSystem : public IOSystem {
     }
 
     // -------------------------------------------------------------------
-    /** Compare two paths */
+    /// @brief Compare two paths
     bool ComparePaths(const char* one, const char* second) const override {
         return existing_io ? existing_io->ComparePaths(one, second) : false;
     }
 
+    /// @brief Will push the directory.
     bool PushDirectory( const std::string &path ) override {
         return existing_io ? existing_io->PushDirectory(path) : false;
     }
 
+    /// @brief Will return the current directory from the stack top.
     const std::string &CurrentDirectory() const override {
         static std::string empty;
         return existing_io ? existing_io->CurrentDirectory() : empty;
     }
 
+    /// @brief Returns the stack size.
     size_t StackSize() const override {
         return existing_io ? existing_io->StackSize() : 0;
     }
 
+    /// @brief Will pop the upper directory.
     bool PopDirectory() override {
         return existing_io ? existing_io->PopDirectory() : false;
     }
 
+    /// @brief Will create the directory.
     bool CreateDirectory( const std::string &path ) override {
         return existing_io ? existing_io->CreateDirectory(path) : false;
     }
 
+    /// @brief Will change the directory.
     bool ChangeDirectory( const std::string &path ) override {
         return existing_io ? existing_io->ChangeDirectory(path) : false;
     }
 
+    /// @brief Will delete the file.
     bool DeleteFile( const std::string &file ) override {
         return existing_io ? existing_io->DeleteFile(file) : false;
     }
@@ -247,4 +236,4 @@ class MemoryIOSystem : public IOSystem {
 
 } // end namespace Assimp
 
-#endif
+#endif // AI_MEMORYIOSTREAM_H_INC
diff --git a/D3D11Engine/include/assimp/NullLogger.hpp b/D3D11Engine/include/assimp/NullLogger.hpp
index 8277b014..1b594ea2 100644
--- a/D3D11Engine/include/assimp/NullLogger.hpp
+++ b/D3D11Engine/include/assimp/NullLogger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/D3D11Engine/include/assimp/ObjMaterial.h b/D3D11Engine/include/assimp/ObjMaterial.h
new file mode 100644
index 00000000..9c511916
--- /dev/null
+++ b/D3D11Engine/include/assimp/ObjMaterial.h
@@ -0,0 +1,84 @@
+/*
+---------------------------------------------------------------------------
+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 OBJMATERIAL.h
+ *  @brief Obj-specific material macros
+ *
+ */
+
+#ifndef AI_OBJMATERIAL_H_INC
+#define AI_OBJMATERIAL_H_INC
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/material.h>
+
+// ---------------------------------------------------------------------------
+
+// the original illum property
+#define AI_MATKEY_OBJ_ILLUM "$mat.illum", 0, 0
+
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Pure key names for all obj texture-related properties
+//! @cond MATS_DOC_FULL
+
+// support for bump -bm
+#define _AI_MATKEY_OBJ_BUMPMULT_BASE "$tex.bumpmult"
+//! @endcond
+
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_OBJ_BUMPMULT(type, N) _AI_MATKEY_OBJ_BUMPMULT_BASE, type, N
+
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_OBJ_BUMPMULT_NORMALS(N) \
+    AI_MATKEY_OBJ_BUMPMULT(aiTextureType_NORMALS, N)
+
+#define AI_MATKEY_OBJ_BUMPMULT_HEIGHT(N) \
+    AI_MATKEY_OBJ_BUMPMULT(aiTextureType_HEIGHT, N)
+
+//! @endcond
+
+
+#endif
diff --git a/D3D11Engine/include/assimp/ParsingUtils.h b/D3D11Engine/include/assimp/ParsingUtils.h
index b5074869..b08f2322 100644
--- a/D3D11Engine/include/assimp/ParsingUtils.h
+++ b/D3D11Engine/include/assimp/ParsingUtils.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/Profiler.h b/D3D11Engine/include/assimp/Profiler.h
index 2f2c72bf..3b9263b4 100644
--- a/D3D11Engine/include/assimp/Profiler.h
+++ b/D3D11Engine/include/assimp/Profiler.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -68,9 +68,7 @@ using namespace Formatter;
  */
 class Profiler {
 public:
-    Profiler() {
-        // empty
-    }
+    Profiler() = default;
 
 
     /** Start a named timer */
diff --git a/D3D11Engine/include/assimp/ProgressHandler.hpp b/D3D11Engine/include/assimp/ProgressHandler.hpp
index a4201540..93d88165 100644
--- a/D3D11Engine/include/assimp/ProgressHandler.hpp
+++ b/D3D11Engine/include/assimp/ProgressHandler.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -67,14 +67,11 @@ class ASSIMP_API ProgressHandler
 {
 protected:
     /// @brief  Default constructor
-    ProgressHandler () AI_NO_EXCEPT {
-        // empty
-    }
+    ProgressHandler () AI_NO_EXCEPT = default;
 
 public:
     /// @brief  Virtual destructor.
-    virtual ~ProgressHandler () {
-    }
+    virtual ~ProgressHandler () = default;
 
     // -------------------------------------------------------------------
     /** @brief Progress callback.
diff --git a/D3D11Engine/include/assimp/RemoveComments.h b/D3D11Engine/include/assimp/RemoveComments.h
index 32f2c672..c2defff6 100644
--- a/D3D11Engine/include/assimp/RemoveComments.h
+++ b/D3D11Engine/include/assimp/RemoveComments.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/SGSpatialSort.h b/D3D11Engine/include/assimp/SGSpatialSort.h
index 23a3cb53..96feefab 100644
--- a/D3D11Engine/include/assimp/SGSpatialSort.h
+++ b/D3D11Engine/include/assimp/SGSpatialSort.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/D3D11Engine/include/assimp/SceneCombiner.h b/D3D11Engine/include/assimp/SceneCombiner.h
index 809ac30e..d6096900 100644
--- a/D3D11Engine/include/assimp/SceneCombiner.h
+++ b/D3D11Engine/include/assimp/SceneCombiner.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -191,13 +191,9 @@ struct SceneHelper {
  */
 class ASSIMP_API SceneCombiner {
     // class cannot be instanced
-    SceneCombiner() {
-        // empty
-    }
+    SceneCombiner() = delete;
 
-    ~SceneCombiner() {
-        // empty
-    }
+    ~SceneCombiner() = delete;
 
 public:
     // -------------------------------------------------------------------
@@ -361,6 +357,7 @@ class ASSIMP_API SceneCombiner {
     static void Copy(aiNodeAnim **dest, const aiNodeAnim *src);
     static void Copy(aiMeshMorphAnim **dest, const aiMeshMorphAnim *src);
     static void Copy(aiMetadata **dest, const aiMetadata *src);
+    static void Copy(aiString **dest, const aiString *src);
 
     // recursive, of course
     static void Copy(aiNode **dest, const aiNode *src);
diff --git a/D3D11Engine/include/assimp/SkeletonMeshBuilder.h b/D3D11Engine/include/assimp/SkeletonMeshBuilder.h
index 2479f430..2929aaa6 100644
--- a/D3D11Engine/include/assimp/SkeletonMeshBuilder.h
+++ b/D3D11Engine/include/assimp/SkeletonMeshBuilder.h
@@ -4,8 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -102,7 +101,7 @@ class ASSIMP_API SkeletonMeshBuilder {
     /** Creates a dummy material and returns it. */
     aiMaterial *CreateMaterial();
 
-protected:
+private:
     /** space to assemble the mesh data: points */
     std::vector<aiVector3D> mVertices;
 
diff --git a/D3D11Engine/include/assimp/SmallVector.h b/D3D11Engine/include/assimp/SmallVector.h
index fb78f5a9..60ad2641 100644
--- a/D3D11Engine/include/assimp/SmallVector.h
+++ b/D3D11Engine/include/assimp/SmallVector.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/SmoothingGroups.h b/D3D11Engine/include/assimp/SmoothingGroups.h
index 75441788..4625a291 100644
--- a/D3D11Engine/include/assimp/SmoothingGroups.h
+++ b/D3D11Engine/include/assimp/SmoothingGroups.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/D3D11Engine/include/assimp/SmoothingGroups.inl b/D3D11Engine/include/assimp/SmoothingGroups.inl
index 08c2dfa5..d5fff5bf 100644
--- a/D3D11Engine/include/assimp/SmoothingGroups.inl
+++ b/D3D11Engine/include/assimp/SmoothingGroups.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/SpatialSort.h b/D3D11Engine/include/assimp/SpatialSort.h
index c0c4a029..cd055450 100644
--- a/D3D11Engine/include/assimp/SpatialSort.h
+++ b/D3D11Engine/include/assimp/SpatialSort.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -162,7 +162,7 @@ class ASSIMP_API SpatialSort {
         unsigned int mIndex; ///< The vertex referred by this entry
         aiVector3D mPosition; ///< Position
         /// Distance of this vertex to the sorting plane. This is set by Finalize.
-        ai_real mDistance; 
+        ai_real mDistance;
 
         Entry() AI_NO_EXCEPT
                 : mIndex(std::numeric_limits<unsigned int>::max()),
diff --git a/D3D11Engine/include/assimp/StandardShapes.h b/D3D11Engine/include/assimp/StandardShapes.h
index 7084427b..77880cf9 100644
--- a/D3D11Engine/include/assimp/StandardShapes.h
+++ b/D3D11Engine/include/assimp/StandardShapes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/D3D11Engine/include/assimp/StreamReader.h b/D3D11Engine/include/assimp/StreamReader.h
index c6c17762..44b24a33 100644
--- a/D3D11Engine/include/assimp/StreamReader.h
+++ b/D3D11Engine/include/assimp/StreamReader.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/StreamWriter.h b/D3D11Engine/include/assimp/StreamWriter.h
index f787a3fa..50e28447 100644
--- a/D3D11Engine/include/assimp/StreamWriter.h
+++ b/D3D11Engine/include/assimp/StreamWriter.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -68,8 +66,7 @@ namespace Assimp {
  */
 // --------------------------------------------------------------------------------------------
 template <bool SwapEndianess = false, bool RuntimeSwitch = false>
-class StreamWriter
-{
+class StreamWriter {
     enum {
         INITIAL_CAPACITY = 1024
     };
diff --git a/D3D11Engine/include/assimp/StringComparison.h b/D3D11Engine/include/assimp/StringComparison.h
index b0161664..0518d426 100644
--- a/D3D11Engine/include/assimp/StringComparison.h
+++ b/D3D11Engine/include/assimp/StringComparison.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/D3D11Engine/include/assimp/StringUtils.h b/D3D11Engine/include/assimp/StringUtils.h
index 025a826d..cd872678 100644
--- a/D3D11Engine/include/assimp/StringUtils.h
+++ b/D3D11Engine/include/assimp/StringUtils.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <sstream>
 #include <iomanip>
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 #define AI_SIZEFMT "%Iu"
 #else
 #define AI_SIZEFMT "%zu"
diff --git a/D3D11Engine/include/assimp/Subdivision.h b/D3D11Engine/include/assimp/Subdivision.h
index 095550a1..11412036 100644
--- a/D3D11Engine/include/assimp/Subdivision.h
+++ b/D3D11Engine/include/assimp/Subdivision.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -122,10 +122,7 @@ class ASSIMP_API Subdivider {
 
 };
 
-inline
-Subdivider::~Subdivider() {
-    // empty
-}
+inline Subdivider::~Subdivider() = default;
 
 } // end namespace Assimp
 
diff --git a/D3D11Engine/include/assimp/TinyFormatter.h b/D3D11Engine/include/assimp/TinyFormatter.h
index 112f1901..df2a32ec 100644
--- a/D3D11Engine/include/assimp/TinyFormatter.h
+++ b/D3D11Engine/include/assimp/TinyFormatter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -119,29 +119,41 @@ class basic_formatter {
      * work for const references, so many function prototypes will
      * include const basic_formatter<T>& s but might still want to
      * modify the formatted string without the need for a full copy.*/
-    template <typename TToken>
-    const basic_formatter& operator << (const TToken& s) const {
+    template <typename TToken, typename std::enable_if<!std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    const basic_formatter &operator<<(const TToken &s) const {
         underlying << s;
         return *this;
     }
 
-    template <typename TToken>
-    basic_formatter& operator << (const TToken& s) {
+    template <typename TToken, typename std::enable_if<std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    const basic_formatter &operator<<(const TToken &s) const {
+        underlying << s.what();
+        return *this;
+    }
+
+    template <typename TToken, typename std::enable_if<!std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    basic_formatter &operator<<(const TToken &s) {
         underlying << s;
         return *this;
     }
 
+    template <typename TToken, typename std::enable_if<std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    basic_formatter &operator<<(const TToken &s) {
+        underlying << s.what();
+        return *this;
+    }
+
 
     // comma operator overloaded as well, choose your preferred way.
     template <typename TToken>
     const basic_formatter& operator, (const TToken& s) const {
-        underlying << s;
+        *this << s;
         return *this;
     }
 
     template <typename TToken>
     basic_formatter& operator, (const TToken& s) {
-        underlying << s;
+        *this << s;
         return *this;
     }
 
@@ -149,7 +161,7 @@ class basic_formatter {
     // See https://sourceforge.net/projects/assimp/forums/forum/817654/topic/4372824
     template <typename TToken>
     basic_formatter& operator, (TToken& s) {
-        underlying << s;
+        *this << s;
         return *this;
     }
 
diff --git a/D3D11Engine/include/assimp/Vertex.h b/D3D11Engine/include/assimp/Vertex.h
index ad5ff476..3fc97450 100644
--- a/D3D11Engine/include/assimp/Vertex.h
+++ b/D3D11Engine/include/assimp/Vertex.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -97,15 +97,21 @@ namespace Assimp    {
  *  to *all* vertex components equally. This is useful for stuff like interpolation
  *  or subdivision, but won't work if special handling is required for some vertex components. */
 // ------------------------------------------------------------------------------------------------
-class Vertex {
+struct Vertex {
     friend Vertex operator + (const Vertex&,const Vertex&);
     friend Vertex operator - (const Vertex&,const Vertex&);
     friend Vertex operator * (const Vertex&,ai_real);
     friend Vertex operator / (const Vertex&,ai_real);
     friend Vertex operator * (ai_real, const Vertex&);
 
-public:
-    Vertex() {}
+    aiVector3D position;
+    aiVector3D normal;
+    aiVector3D tangent, bitangent;
+
+    aiVector3D texcoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    Vertex() = default;
 
     // ----------------------------------------------------------------------------
     /** Extract a particular vertex from a mesh and interleave all components */
@@ -135,7 +141,9 @@ class Vertex {
     /** Extract a particular vertex from a anim mesh and interleave all components */
     explicit Vertex(const aiAnimMesh* msh, unsigned int idx) {
         ai_assert(idx < msh->mNumVertices);
-        position = msh->mVertices[idx];
+        if (msh->HasPositions()) {
+            position = msh->mVertices[idx];
+        }
 
         if (msh->HasNormals()) {
             normal = msh->mNormals[idx];
@@ -176,7 +184,7 @@ class Vertex {
     }
 
     // ----------------------------------------------------------------------------
-    /** Convert back to non-interleaved storage */
+    /// Convert back to non-interleaved storage
     void SortBack(aiMesh* out, unsigned int idx) const {
         ai_assert(idx<out->mNumVertices);
         out->mVertices[idx] = position;
@@ -202,7 +210,7 @@ class Vertex {
 private:
 
     // ----------------------------------------------------------------------------
-    /** Construct from two operands and a binary operation to combine them */
+    /// Construct from two operands and a binary operation to combine them
     template <template <typename t> class op> static Vertex BinaryOp(const Vertex& v0, const Vertex& v1) {
         // this is a heavy task for the compiler to optimize ... *pray*
 
@@ -222,7 +230,7 @@ class Vertex {
     }
 
     // ----------------------------------------------------------------------------
-    /** This time binary arithmetic of v0 with a floating-point number */
+    /// This time binary arithmetic of v0 with a floating-point number
     template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, ai_real f) {
         // this is a heavy task for the compiler to optimize ... *pray*
 
@@ -260,15 +268,6 @@ class Vertex {
         }
         return res;
     }
-
-public:
-
-    aiVector3D position;
-    aiVector3D normal;
-    aiVector3D tangent, bitangent;
-
-    aiVector3D texcoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS];
 };
 
 // ------------------------------------------------------------------------------------------------
diff --git a/D3D11Engine/include/assimp/XMLTools.h b/D3D11Engine/include/assimp/XMLTools.h
index e0082a36..b2766f19 100644
--- a/D3D11Engine/include/assimp/XMLTools.h
+++ b/D3D11Engine/include/assimp/XMLTools.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/D3D11Engine/include/assimp/XmlParser.h b/D3D11Engine/include/assimp/XmlParser.h
index dfaab516..4ab42ba2 100644
--- a/D3D11Engine/include/assimp/XmlParser.h
+++ b/D3D11Engine/include/assimp/XmlParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,13 +49,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "IOStream.hpp"
 
 #include <pugixml.hpp>
+#include <utility>
 #include <vector>
 
 namespace Assimp {
 
 /// @brief  Will find a node by its name.
 struct find_node_by_name_predicate {
-    std::string mName;
+    /// @brief The default constructor.
+    find_node_by_name_predicate() = default;
+
+
+    std::string mName; ///< The name to find.
     find_node_by_name_predicate(const std::string &name) :
             mName(name) {
         // empty
@@ -67,7 +72,7 @@ struct find_node_by_name_predicate {
 };
 
 /// @brief  Will convert an attribute to its int value.
-/// @tparam TNodeType The node type.
+/// @tparam[in] TNodeType  The node type.
 template <class TNodeType>
 struct NodeConverter {
 public:
@@ -99,301 +104,385 @@ template <class TNodeType>
 class TXmlParser {
 public:
     /// @brief The default class constructor.
-    TXmlParser() :
-            mDoc(nullptr),
-            mData() {
-        // empty
-    }
+    TXmlParser();
 
     ///	@brief  The class destructor.
-    ~TXmlParser() {
-        clear();
-    }
+    ~TXmlParser();
 
     ///	@brief  Will clear the parsed xml-file.
-    void clear() {
-        if (mData.empty()) {
-            mDoc = nullptr;
-            return;
-        }
-        mData.clear();
-        delete mDoc;
-        mDoc = nullptr;
-    }
+    void clear();
 
     ///	@brief  Will search for a child-node by its name
-    /// @param  name     [in] The name of the child-node.
+    /// @param[in] name     The name of the child-node.
     /// @return The node instance or nullptr, if nothing was found.
-    TNodeType *findNode(const std::string &name) {
-        if (name.empty()) {
-            return nullptr;
-        }
-
-        if (nullptr == mDoc) {
-            return nullptr;
-        }
-
-        find_node_by_name_predicate predicate(name);
-        mCurrent = mDoc->find_node(predicate);
-        if (mCurrent.empty()) {
-            return nullptr;
-        }
-
-        return &mCurrent;
-    }
+    TNodeType *findNode(const std::string &name);
 
     /// @brief  Will return true, if the node is a child-node.
-    /// @param  name    [in] The name of the child node to look for.
+    /// @param[in]  name    The name of the child node to look for.
     /// @return true, if the node is a child-node or false if not.
-    bool hasNode(const std::string &name) {
-        return nullptr != findNode(name);
-    }
+    bool hasNode(const std::string &name);
 
     /// @brief  Will parse an xml-file from a given stream.
-    /// @param  stream      The input stream.
+    /// @param[in] stream      The input stream.
     /// @return true, if the parsing was successful, false if not.
-    bool parse(IOStream *stream) {
-        if (nullptr == stream) {
-            ASSIMP_LOG_DEBUG("Stream is nullptr.");
-            return false;
-        }
-
-        const size_t len = stream->FileSize();
-        mData.resize(len + 1);
-        memset(&mData[0], '\0', len + 1);
-        stream->Read(&mData[0], 1, len);
-
-        mDoc = new pugi::xml_document();
-        pugi::xml_parse_result parse_result = mDoc->load_string(&mData[0], pugi::parse_full);
-        if (parse_result.status == pugi::status_ok) {
-            return true;
-        }
-
-        ASSIMP_LOG_DEBUG("Error while parse xml.", std::string(parse_result.description()), " @ ", parse_result.offset);
-
-        return false;
-    }
+    bool parse(IOStream *stream);
 
-    /// @brief  Will return truem if a root node is there.
+    /// @brief  Will return true if a root node is there.
     /// @return true in case of an existing root.
-    bool hasRoot() const {
-        return nullptr != mDoc;
-    }
+    bool hasRoot() const;
+
     /// @brief  Will return the document pointer, is nullptr if no xml-file was parsed.
     /// @return The pointer showing to the document.
-    pugi::xml_document *getDocument() const {
-        return mDoc;
-    }
+    pugi::xml_document *getDocument() const;
 
     /// @brief  Will return the root node, const version.
     /// @return The root node.
-    const TNodeType getRootNode() const {
-        static pugi::xml_node none;
-        if (nullptr == mDoc) {
-            return none;
-        }
-        return mDoc->root();
-    }
+    const TNodeType getRootNode() const;
 
     /// @brief  Will return the root node, non-const version.
     /// @return The root node.
-    TNodeType getRootNode() {
-        static pugi::xml_node none;
-        if (nullptr == mDoc) {
-            return none;
-        }
-        return mDoc->root();
-    }
+    TNodeType getRootNode();
 
     /// @brief Will check if a node with the given name is in.
-    /// @param node     [in] The node to look in.
-    /// @param name     [in] The name of the child-node.
+    /// @param[in] node     The node to look in.
+    /// @param[in] name     The name of the child-node.
     /// @return true, if node was found, false if not.
-    static inline bool hasNode(XmlNode &node, const char *name) {
-        pugi::xml_node child = node.find_child(find_node_by_name_predicate(name));
-        return !child.empty();
-    }
+    static inline bool hasNode(XmlNode &node, const char *name);
 
     /// @brief Will check if an attribute is part of the XmlNode.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in} The attribute name to look for.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
     /// @return true, if the was found, false if not.
-    static inline bool hasAttribute(XmlNode &xmlNode, const char *name) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        return !attr.empty();
-    }
+    static inline bool hasAttribute(XmlNode &xmlNode, const char *name);
 
     /// @brief Will try to get an unsigned int attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The unsigned int value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The unsigned int value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is an unsigned int.
-    static inline bool getUIntAttribute(XmlNode &xmlNode, const char *name, unsigned int &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-
-        val = attr.as_uint();
-        return true;
-    }
+    static inline bool getUIntAttribute(XmlNode &xmlNode, const char *name, unsigned int &val);
 
     /// @brief Will try to get an int attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The int value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The int value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is an int.
-    static inline bool getIntAttribute(XmlNode &xmlNode, const char *name, int &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-
-        val = attr.as_int();
-        return true;
-    }
+    static inline bool getIntAttribute(XmlNode &xmlNode, const char *name, int &val);
 
     /// @brief Will try to get a real attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The real value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The real value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is a real.
-    static inline bool getRealAttribute(XmlNode &xmlNode, const char *name, ai_real &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-#ifdef ASSIMP_DOUBLE_PRECISION
-        val = attr.as_double();
-#else
-        val = attr.as_float();
-#endif
-        return true;
-    }
+    static inline bool getRealAttribute(XmlNode &xmlNode, const char *name, ai_real &val);
 
     /// @brief Will try to get a float attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The float value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The float value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is a float.
-    static inline bool getFloatAttribute(XmlNode &xmlNode, const char *name, float &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-
-        val = attr.as_float();
-        return true;
-    }
+    static inline bool getFloatAttribute(XmlNode &xmlNode, const char *name, float &val);
 
     /// @brief Will try to get a double attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The double value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The double value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is a double.
-    static inline bool getDoubleAttribute(XmlNode &xmlNode, const char *name, double &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-
-        val = attr.as_double();
-        return true;
-    }
+    static inline bool getDoubleAttribute(XmlNode &xmlNode, const char *name, double &val);
 
     /// @brief Will try to get a std::string attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The std::string value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The std::string value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is a std::string.
-    static inline bool getStdStrAttribute(XmlNode &xmlNode, const char *name, std::string &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-
-        val = attr.as_string();
-        return true;
-    }
+    static inline bool getStdStrAttribute(XmlNode &xmlNode, const char *name, std::string &val);
 
     /// @brief Will try to get a bool attribute value.
-    /// @param xmlNode  [in] The node to search in.
-    /// @param name     [in] The attribute name to look for.
-    /// @param val      [out] The bool value from the attribute.
+    /// @param[in] xmlNode  The node to search in.
+    /// @param[in] name     The attribute name to look for.
+    /// @param[out] val     The bool value from the attribute.
     /// @return true, if the node contains an attribute with the given name and if the value is a bool.
-    static inline bool getBoolAttribute(XmlNode &xmlNode, const char *name, bool &val) {
-        pugi::xml_attribute attr = xmlNode.attribute(name);
-        if (attr.empty()) {
-            return false;
-        }
-
-        val = attr.as_bool();
-        return true;
-    }
+    static inline bool getBoolAttribute(XmlNode &xmlNode, const char *name, bool &val);
 
     /// @brief Will try to get the value of the node as a string.
-    /// @param node     [in] The node to search in.
-    /// @param text     [out] The value as a text.
+    /// @param[in] node     The node to search in.
+    /// @param[out] text    The value as a text.
     /// @return true, if the value can be read out.
-    static inline bool getValueAsString(XmlNode &node, std::string &text) {
-        text = std::string();
-        if (node.empty()) {
-            return false;
-        }
+    static inline bool getValueAsString(XmlNode &node, std::string &text);
 
-        text = node.text().as_string();
+    /// @brief Will try to get the value of the node as a float.
+    /// @param[in] node     The node to search in.
+    /// @param[out] text    The value as a float.
+    /// @return true, if the value can be read out.
+    static inline bool getValueAsFloat(XmlNode &node, ai_real &v);
 
-        return true;
-    }
+    /// @brief Will try to get the value of the node as an integer.
+    /// @param[in] node     The node to search in.
+    /// @param[out] text    The value as a int.
+    /// @return true, if the value can be read out.
+    static inline bool getValueAsInt(XmlNode &node, int &v);
 
-    /// @brief Will try to get the value of the node as a float.
-    /// @param node     [in] The node to search in.
-    /// @param text     [out] The value as a float.
+    /// @brief Will try to get the value of the node as an bool.
+    /// @param[in] node     The node to search in.
+    /// @param[out] text    The value as a bool.
     /// @return true, if the value can be read out.
-    static inline bool getValueAsFloat(XmlNode &node, ai_real &v) {
-        if (node.empty()) {
-            return false;
+    static inline bool getValueAsBool(XmlNode &node, bool &v);
+
+private:
+    pugi::xml_document *mDoc;
+    TNodeType mCurrent;
+    std::vector<char> mData;
+};
+
+template <class TNodeType>
+inline TXmlParser<TNodeType>::TXmlParser() :
+        mDoc(nullptr),
+        mData() {
+    // empty
+}
+
+template <class TNodeType>
+inline TXmlParser<TNodeType>::~TXmlParser() {
+    clear();
+}
+
+template <class TNodeType>
+inline void TXmlParser<TNodeType>::clear() {
+    if (mData.empty()) {
+        if (mDoc) {
+            delete mDoc;
         }
+        mDoc = nullptr;
+        return;
+    }
 
-        v = node.text().as_float();
+    mData.clear();
+    delete mDoc;
+    mDoc = nullptr;
+}
 
-        return true;
+template <class TNodeType>
+inline TNodeType *TXmlParser<TNodeType>::findNode(const std::string &name) {
+    if (name.empty()) {
+        return nullptr;
     }
 
-    /// @brief Will try to get the value of the node as an integer.
-    /// @param node     [in] The node to search in.
-    /// @param text     [out] The value as a int.
-    /// @return true, if the value can be read out.
-    static inline bool getValueAsInt(XmlNode &node, int &v) {
-        if (node.empty()) {
-            return false;
-        }
+    if (nullptr == mDoc) {
+        return nullptr;
+    }
 
-        v = node.text().as_int();
+    find_node_by_name_predicate predicate(name);
+    mCurrent = mDoc->find_node(std::move(predicate));
+    if (mCurrent.empty()) {
+        return nullptr;
+    }
 
-        return true;
+    return &mCurrent;
+}
+
+template <class TNodeType>
+bool TXmlParser<TNodeType>::hasNode(const std::string &name) {
+    return nullptr != findNode(name);
+}
+
+template <class TNodeType>
+bool TXmlParser<TNodeType>::parse(IOStream *stream) {
+    if (hasRoot()) {
+        clear();
     }
 
-    /// @brief Will try to get the value of the node as an bool.
-    /// @param node     [in] The node to search in.
-    /// @param text     [out] The value as a bool.
-    /// @return true, if the value can be read out.
-    static inline bool getValueAsBool(XmlNode& node, bool& v)
-    {
-        if (node.empty()) {
-            return false;
-        }
+    if (nullptr == stream) {
+        ASSIMP_LOG_DEBUG("Stream is nullptr.");
+        return false;
+    }
 
-        v = node.text().as_bool();
+    const size_t len = stream->FileSize();
+    mData.resize(len + 1);
+    memset(&mData[0], '\0', len + 1);
+    stream->Read(&mData[0], 1, len);
 
+    mDoc = new pugi::xml_document();
+    // load_string assumes native encoding (aka always utf-8 per build options)
+    //pugi::xml_parse_result parse_result = mDoc->load_string(&mData[0], pugi::parse_full);
+     pugi::xml_parse_result parse_result = mDoc->load_buffer(&mData[0], mData.size(), pugi::parse_full);
+    if (parse_result.status == pugi::status_ok) {
         return true;
     }
 
-private:
-    pugi::xml_document *mDoc;
-    TNodeType mCurrent;
-    std::vector<char> mData;
-};
+    ASSIMP_LOG_DEBUG("Error while parse xml.", std::string(parse_result.description()), " @ ", parse_result.offset);
+
+    return false;
+}
+
+template <class TNodeType>
+bool TXmlParser<TNodeType>::hasRoot() const {
+    return nullptr != mDoc;
+}
+
+template <class TNodeType>
+pugi::xml_document *TXmlParser<TNodeType>::getDocument() const {
+    return mDoc;
+}
+
+template <class TNodeType>
+const TNodeType TXmlParser<TNodeType>::getRootNode() const {
+    static pugi::xml_node none;
+    if (nullptr == mDoc) {
+        return none;
+    }
+    return mDoc->root();
+}
+
+template <class TNodeType>
+TNodeType TXmlParser<TNodeType>::getRootNode() {
+    static pugi::xml_node none;
+    if (nullptr == mDoc) {
+        return none;
+    }
+
+    return mDoc->root();
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::hasNode(XmlNode &node, const char *name) {
+    pugi::xml_node child = node.find_child(find_node_by_name_predicate(name));
+    return !child.empty();
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::hasAttribute(XmlNode &xmlNode, const char *name) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    return !attr.empty();
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getUIntAttribute(XmlNode &xmlNode, const char *name, unsigned int &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+
+    val = attr.as_uint();
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getIntAttribute(XmlNode &xmlNode, const char *name, int &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+
+    val = attr.as_int();
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getRealAttribute(XmlNode &xmlNode, const char *name, ai_real &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+#ifdef ASSIMP_DOUBLE_PRECISION
+    val = attr.as_double();
+#else
+    val = attr.as_float();
+#endif
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getFloatAttribute(XmlNode &xmlNode, const char *name, float &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+
+    val = attr.as_float();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getDoubleAttribute(XmlNode &xmlNode, const char *name, double &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+
+    val = attr.as_double();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getStdStrAttribute(XmlNode &xmlNode, const char *name, std::string &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+
+    val = attr.as_string();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getBoolAttribute(XmlNode &xmlNode, const char *name, bool &val) {
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    if (attr.empty()) {
+        return false;
+    }
+
+    val = attr.as_bool();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getValueAsString(XmlNode &node, std::string &text) {
+    text = std::string();
+    if (node.empty()) {
+        return false;
+    }
+
+    text = node.text().as_string();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getValueAsFloat(XmlNode &node, ai_real &v) {
+    if (node.empty()) {
+        return false;
+    }
+
+    v = node.text().as_float();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getValueAsInt(XmlNode &node, int &v) {
+    if (node.empty()) {
+        return false;
+    }
+
+    v = node.text().as_int();
+
+    return true;
+}
+
+template <class TNodeType>
+inline bool TXmlParser<TNodeType>::getValueAsBool(XmlNode &node, bool &v) {
+    if (node.empty()) {
+        return false;
+    }
+
+    v = node.text().as_bool();
+
+    return true;
+}
 
 using XmlParser = TXmlParser<pugi::xml_node>;
 
@@ -419,10 +508,8 @@ class XmlNodeIterator {
         }
     }
 
-    ///	@brief  The class destructor.
-    ~XmlNodeIterator() {
-        // empty
-    }
+    ///	@brief  The class destructor, default implementation.
+    ~XmlNodeIterator() = default;
 
     ///	@brief  Will iterate through all children in pre-order iteration.
     /// @param  node    [in] The nod to iterate through.
diff --git a/D3D11Engine/include/assimp/ZipArchiveIOSystem.h b/D3D11Engine/include/assimp/ZipArchiveIOSystem.h
index 842a982d..9f3a4783 100644
--- a/D3D11Engine/include/assimp/ZipArchiveIOSystem.h
+++ b/D3D11Engine/include/assimp/ZipArchiveIOSystem.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -63,7 +63,7 @@ class ZipArchiveIOSystem : public IOSystem {
     //! Open a Zip using the proffered IOSystem
     ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
     ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
-    virtual ~ZipArchiveIOSystem();
+    virtual ~ZipArchiveIOSystem() override;
     bool Exists(const char* pFilename) const override;
     char getOsSeparator() const override;
     IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
diff --git a/D3D11Engine/include/assimp/aabb.h b/D3D11Engine/include/assimp/aabb.h
index a6ccdd45..b38aa169 100644
--- a/D3D11Engine/include/assimp/aabb.h
+++ b/D3D11Engine/include/assimp/aabb.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,8 +50,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/vector3.h>
 
 // ---------------------------------------------------------------------------
-/** 
- *  An axis-aligned bounding box.  
+/**
+ *  An axis-aligned bounding box.
  */
 struct aiAABB {
     C_STRUCT aiVector3D mMin;
@@ -73,9 +73,7 @@ struct aiAABB {
     }
 
     ///	@brief  The class destructor.
-    ~aiAABB() {
-        // empty
-    }
+    ~aiAABB() = default;
 
 #endif // __cplusplus
 };
diff --git a/D3D11Engine/include/assimp/ai_assert.h b/D3D11Engine/include/assimp/ai_assert.h
index b4f1ef8b..e49a482d 100644
--- a/D3D11Engine/include/assimp/ai_assert.h
+++ b/D3D11Engine/include/assimp/ai_assert.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -55,7 +55,7 @@ namespace Assimp {
 
 /// @brief Assert violation behavior can be customized: see AssertHandler.h.
 /// @param failedExpression     The expression to validate.
-/// @param file                 The file location    
+/// @param file                 The file location
 /// @param line                 The line number
 ASSIMP_API void aiAssertViolation(const char* failedExpression, const char* file, int line);
 
diff --git a/D3D11Engine/include/assimp/anim.h b/D3D11Engine/include/assimp/anim.h
index 8a73297a..49f0d501 100644
--- a/D3D11Engine/include/assimp/anim.h
+++ b/D3D11Engine/include/assimp/anim.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -98,7 +98,7 @@ struct aiVectorKey {
     bool operator<(const aiVectorKey &rhs) const {
         return mTime < rhs.mTime;
     }
-    
+
     bool operator>(const aiVectorKey &rhs) const {
         return mTime > rhs.mTime;
     }
@@ -132,7 +132,7 @@ struct aiQuatKey {
     bool operator==(const aiQuatKey &rhs) const {
         return rhs.mValue == this->mValue;
     }
-    
+
     bool operator!=(const aiQuatKey &rhs) const {
         return rhs.mValue != this->mValue;
     }
@@ -141,7 +141,7 @@ struct aiQuatKey {
     bool operator<(const aiQuatKey &rhs) const {
         return mTime < rhs.mTime;
     }
-    
+
     bool operator>(const aiQuatKey &rhs) const {
         return mTime > rhs.mTime;
     }
@@ -198,7 +198,10 @@ struct aiMeshMorphKey {
     /** The time of this key */
     double mTime;
 
-    /** The values and weights at the time of this key */
+    /** The values and weights at the time of this key
+     *   - mValues: index of attachment mesh to apply weight at the same position in mWeights
+     *   - mWeights: weight to apply to the blend shape index at the same position in mValues
+     */
     unsigned int *mValues;
     double *mWeights;
 
diff --git a/D3D11Engine/include/assimp/camera.h b/D3D11Engine/include/assimp/camera.h
index 56c4dbe3..09255fa0 100644
--- a/D3D11Engine/include/assimp/camera.h
+++ b/D3D11Engine/include/assimp/camera.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/cexport.h b/D3D11Engine/include/assimp/cexport.h
index 47b59a62..a45ece39 100644
--- a/D3D11Engine/include/assimp/cexport.h
+++ b/D3D11Engine/include/assimp/cexport.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/cfileio.h b/D3D11Engine/include/assimp/cfileio.h
index 48a728a2..fc1b95ad 100644
--- a/D3D11Engine/include/assimp/cfileio.h
+++ b/D3D11Engine/include/assimp/cfileio.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/cimport.h b/D3D11Engine/include/assimp/cimport.h
index d660eebb..935ed18b 100644
--- a/D3D11Engine/include/assimp/cimport.h
+++ b/D3D11Engine/include/assimp/cimport.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/color4.h b/D3D11Engine/include/assimp/color4.h
index fdd8f031..e1e35493 100644
--- a/D3D11Engine/include/assimp/color4.h
+++ b/D3D11Engine/include/assimp/color4.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/color4.inl b/D3D11Engine/include/assimp/color4.inl
index e5bfdf35..aed3de6f 100644
--- a/D3D11Engine/include/assimp/color4.inl
+++ b/D3D11Engine/include/assimp/color4.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/commonMetaData.h b/D3D11Engine/include/assimp/commonMetaData.h
index 28de1590..ccded585 100644
--- a/D3D11Engine/include/assimp/commonMetaData.h
+++ b/D3D11Engine/include/assimp/commonMetaData.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/config.h b/D3D11Engine/include/assimp/config.h
index 1358add5..8a5a2aef 100644
--- a/D3D11Engine/include/assimp/config.h
+++ b/D3D11Engine/include/assimp/config.h
@@ -3,8 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -60,7 +59,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_CONFIG_H_INC
 #define AI_CONFIG_H_INC
 
-
 // ###########################################################################
 // LIBRARY SETTINGS
 // General, global settings
@@ -79,7 +77,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_CONFIG_GLOB_MEASURE_TIME  \
     "GLOB_MEASURE_TIME"
 
-
 // ---------------------------------------------------------------------------
 /** @brief Global setting to disable generation of skeleton dummy meshes
  *
@@ -91,34 +88,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \
     "IMPORT_NO_SKELETON_MESHES"
 
-
-
-# if 0 // not implemented yet
-// ---------------------------------------------------------------------------
-/** @brief Set Assimp's multithreading policy.
- *
- * This setting is ignored if Assimp was built without boost.thread
- * support (ASSIMP_BUILD_NO_THREADING, which is implied by ASSIMP_BUILD_BOOST_WORKAROUND).
- * Possible values are: -1 to let Assimp decide what to do, 0 to disable
- * multithreading entirely and any number larger than 0 to force a specific
- * number of threads. Assimp is always free to ignore this settings, which is
- * merely a hint. Usually, the default value (-1) will be fine. However, if
- * Assimp is used concurrently from multiple user threads, it might be useful
- * to limit each Importer instance to a specific number of cores.
- *
- * For more information, see the @link threading Threading page@endlink.
- * Property type: int, default value: -1.
- */
-#define AI_CONFIG_GLOB_MULTITHREADING  \
-    "GLOB_MULTITHREADING"
-#endif
-
 // ###########################################################################
 // POST PROCESSING SETTINGS
 // Various stuff to fine-tune the behavior of a specific post processing step.
 // ###########################################################################
 
-
 // ---------------------------------------------------------------------------
 /** @brief Maximum bone count per mesh for the SplitbyBoneCount step.
  *
@@ -131,13 +105,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_CONFIG_PP_SBBC_MAX_BONES \
     "PP_SBBC_MAX_BONES"
 
-
 // default limit for bone count
 #if (!defined AI_SBBC_DEFAULT_MAX_BONES)
 #   define AI_SBBC_DEFAULT_MAX_BONES        60
 #endif
 
-
 // ---------------------------------------------------------------------------
 /** @brief  Specifies the maximum angle that may be between two vertex tangents
  *         that their tangents and bi-tangents are smoothed.
@@ -174,7 +146,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \
     "PP_GSN_MAX_SMOOTHING_ANGLE"
 
-
 // ---------------------------------------------------------------------------
 /** @brief Sets the colormap (= palette) to be used to decode embedded
  *         textures in MDL (Quake or 3DGS) files.
@@ -270,7 +241,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ---------------------------------------------------------------------------
 /**
  *  @brief  Configures the #aiProcess_FindDegenerates to check the area of a
- *  trinagle to be greates than e-6. If this is not the case the triangle will
+ *  triangle to be greater than e-6. If this is not the case the triangle will
  *  be removed if #AI_CONFIG_PP_FD_REMOVE is set to true.
  */
 #define AI_CONFIG_PP_FD_CHECKAREA \
@@ -541,7 +512,6 @@ enum aiComponent
 #define AI_CONFIG_FAVOUR_SPEED              \
  "FAVOUR_SPEED"
 
-
 // ###########################################################################
 // IMPORTER SETTINGS
 // Various stuff to fine-tune the behaviour of specific importer plugins.
@@ -691,6 +661,15 @@ enum aiComponent
 #define AI_CONFIG_FBX_CONVERT_TO_M \
     "AI_CONFIG_FBX_CONVERT_TO_M"
 
+// ---------------------------------------------------------------------------
+/** @brief  Will enable the skeleton struct to store bone data.
+ *
+ *  This will decouple the bone coupling to the mesh. This feature is
+ *  experimental.
+ */
+#define AI_CONFIG_FBX_USE_SKELETON_BONE_CONTAINER \
+    "AI_CONFIG_FBX_USE_SKELETON_BONE_CONTAINER"
+
 // ---------------------------------------------------------------------------
 /** @brief  Set the vertex animation keyframe to be imported
  *
@@ -1056,6 +1035,15 @@ enum aiComponent
  */
 #define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
 
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader will ignore the provided unit size.
+ *
+ * If this property is set to true, the unit size provided in the file header will
+ * be ignored and the file will be loaded without scaling the assets.
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_COLLADA_IGNORE_UNIT_SIZE "IMPORT_COLLADA_IGNORE_UNIT_SIZE"
+
 // ---------------------------------------------------------------------------
 /** @brief Specifies whether the Collada loader should use Collada names.
  *
@@ -1081,9 +1069,22 @@ enum aiComponent
  *  Point clouds are only a collection of vertices which have nor spatial organization
  *  by a face and the validation process will remove them. Enabling this feature will
  *  switch off the flag and enable the functionality to export pure point clouds.
+ *
+ * Property type: Bool. Default value: false.
  */
 #define AI_CONFIG_EXPORT_POINT_CLOUDS "EXPORT_POINT_CLOUDS"
 
+/** @brief Specifies whether to use the deprecated KHR_materials_pbrSpecularGlossiness extension
+ * 
+ * When this flag is undefined any material with specularity will use the new KHR_materials_specular
+ * extension. Enabling this flag will revert to the deprecated extension. Note that exporting
+ * KHR_materials_pbrSpecularGlossiness with extensions other than KHR_materials_unlit is unsupported,
+ * including the basic pbrMetallicRoughness spec.
+ *
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_USE_GLTF_PBR_SPECULAR_GLOSSINESS "USE_GLTF_PBR_SPECULAR_GLOSSINESS"
+
 /**
  * @brief Specifies the blob name, assimp uses for exporting.
  * 
@@ -1102,7 +1103,7 @@ enum aiComponent
 #define AI_CONFIG_EXPORT_BLOB_NAME "EXPORT_BLOB_NAME"
 
 /**
- *  @brief  Specifies a gobal key factor for scale, float value
+ *  @brief  Specifies a global key factor for scale, float value
  */
 #define AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY "GLOBAL_SCALE_FACTOR"
 
diff --git a/D3D11Engine/include/assimp/defs.h b/D3D11Engine/include/assimp/defs.h
index e5f40199..4fcfb966 100644
--- a/D3D11Engine/include/assimp/defs.h
+++ b/D3D11Engine/include/assimp/defs.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -184,13 +184,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef __GNUC__
 #   define AI_WONT_RETURN_SUFFIX __attribute__((noreturn))
+#elif _MSC_VER
+#if defined(__clang__)
+#   define AI_WONT_RETURN_SUFFIX __attribute__((noreturn))
+#else
+#   define AI_WONT_RETURN_SUFFIX
+#endif
 #else
 #   define AI_WONT_RETURN_SUFFIX
 #endif // (defined __clang__)
 
 #ifdef __cplusplus
 /* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
- * in doxydocs. 
+ * in doxydocs.
  */
 #define C_STRUCT
 #define C_ENUM
@@ -279,11 +285,15 @@ typedef unsigned int ai_uint;
 #define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
 
 /* Tiny macro to convert from radians to degrees and back */
-#define AI_DEG_TO_RAD(x) ((x) * (ai_real)0.0174532925)
-#define AI_RAD_TO_DEG(x) ((x) * (ai_real)57.2957795)
+#define AI_DEG_TO_RAD(x) ((x) * (ai_real) 0.0174532925)
+#define AI_RAD_TO_DEG(x) ((x) * (ai_real) 57.2957795)
 
 /* Numerical limits */
-static const ai_real ai_epsilon = (ai_real)0.00001;
+#ifdef __cplusplus
+constexpr ai_real ai_epsilon = (ai_real) 1e-6;
+#else
+const ai_real ai_epsilon = (ai_real) 1e-6;
+#endif
 
 /* Support for big-endian builds */
 #if defined(__BYTE_ORDER__)
@@ -331,4 +341,6 @@ static const ai_real ai_epsilon = (ai_real)0.00001;
 #define AI_DEBUG_INVALIDATE_PTR(x)
 #endif
 
+#define AI_COUNT_OF(X) (sizeof(X) / sizeof((X)[0]))
+
 #endif // !! AI_DEFINES_H_INC
diff --git a/D3D11Engine/include/assimp/fast_atof.h b/D3D11Engine/include/assimp/fast_atof.h
index 43bbbff6..f2d179d6 100644
--- a/D3D11Engine/include/assimp/fast_atof.h
+++ b/D3D11Engine/include/assimp/fast_atof.h
@@ -39,7 +39,9 @@
 
 namespace Assimp {
 
-const double fast_atof_table[16] =  {  // we write [16] here instead of [] to work around a swig bug
+static constexpr size_t NumItems = 16;
+
+constexpr double fast_atof_table[NumItems] =  {  // we write [16] here instead of [] to work around a swig bug
     0.0,
     0.1,
     0.01,
@@ -58,12 +60,10 @@ const double fast_atof_table[16] =  {  // we write [16] here instead of [] to wo
     0.000000000000001
 };
 
-
 // ------------------------------------------------------------------------------------
 // Convert a string in decimal format to a number
 // ------------------------------------------------------------------------------------
-inline
-unsigned int strtoul10( const char* in, const char** out=0) {
+inline unsigned int strtoul10( const char* in, const char** out=0) {
     unsigned int value = 0;
 
     for ( ;; ) {
@@ -83,8 +83,7 @@ unsigned int strtoul10( const char* in, const char** out=0) {
 // ------------------------------------------------------------------------------------
 // Convert a string in octal format to a number
 // ------------------------------------------------------------------------------------
-inline
-unsigned int strtoul8( const char* in, const char** out=0) {
+inline unsigned int strtoul8( const char* in, const char** out=0) {
     unsigned int value( 0 );
     for ( ;; ) {
         if ( *in < '0' || *in > '7' ) {
@@ -103,8 +102,7 @@ unsigned int strtoul8( const char* in, const char** out=0) {
 // ------------------------------------------------------------------------------------
 // Convert a string in hex format to a number
 // ------------------------------------------------------------------------------------
-inline
-unsigned int strtoul16( const char* in, const char** out=0) {
+inline unsigned int strtoul16( const char* in, const char** out=0) {
     unsigned int value( 0 );
     for ( ;; ) {
         if ( *in >= '0' && *in <= '9' ) {
@@ -128,8 +126,7 @@ unsigned int strtoul16( const char* in, const char** out=0) {
 // Convert just one hex digit
 // Return value is UINT_MAX if the input character is not a hex digit.
 // ------------------------------------------------------------------------------------
-inline
-unsigned int HexDigitToDecimal(char in) {
+inline unsigned int HexDigitToDecimal(char in) {
     unsigned int out( UINT_MAX );
     if ( in >= '0' && in <= '9' ) {
         out = in - '0';
@@ -146,16 +143,14 @@ unsigned int HexDigitToDecimal(char in) {
 // ------------------------------------------------------------------------------------
 // Convert a hex-encoded octet (2 characters, i.e. df or 1a).
 // ------------------------------------------------------------------------------------
-inline
-uint8_t HexOctetToDecimal(const char* in) {
+inline uint8_t HexOctetToDecimal(const char* in) {
     return ((uint8_t)HexDigitToDecimal(in[0])<<4)+(uint8_t)HexDigitToDecimal(in[1]);
 }
 
 // ------------------------------------------------------------------------------------
 // signed variant of strtoul10
 // ------------------------------------------------------------------------------------
-inline
-int strtol10( const char* in, const char** out=0) {
+inline int strtol10( const char* in, const char** out=0) {
     bool inv = (*in=='-');
     if ( inv || *in == '+' ) {
         ++in;
@@ -163,7 +158,11 @@ int strtol10( const char* in, const char** out=0) {
 
     int value = strtoul10(in,out);
     if (inv) {
-        value = -value;
+        if (value < INT_MAX) {
+            value = -value;
+        } else {
+            ASSIMP_LOG_WARN( "Converting the string \"", in, "\" into an inverted value resulted in overflow." );
+        }
     }
     return value;
 }
@@ -174,8 +173,7 @@ int strtol10( const char* in, const char** out=0) {
 // 0NNN   - oct
 // NNN    - dec
 // ------------------------------------------------------------------------------------
-inline
-unsigned int strtoul_cppstyle( const char* in, const char** out=0) {
+inline unsigned int strtoul_cppstyle( const char* in, const char** out=0) {
     if ('0' == in[0]) {
         return 'x' == in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out);
     }
@@ -187,8 +185,7 @@ unsigned int strtoul_cppstyle( const char* in, const char** out=0) {
 // It is mainly used by fast_atof to prevent ugly and unwanted integer overflows.
 // ------------------------------------------------------------------------------------
 template<typename ExceptionType = DeadlyImportError>
-inline
-uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_inout=0) {
+inline uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_inout=0) {
     unsigned int cur = 0;
     uint64_t value = 0;
 
@@ -241,8 +238,7 @@ uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_ino
 // signed variant of strtoul10_64
 // ------------------------------------------------------------------------------------
 template<typename ExceptionType = DeadlyImportError>
-inline
-int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inout = 0) {
+inline int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inout = 0) {
     bool inv = (*in == '-');
     if ( inv || *in == '+' ) {
         ++in;
@@ -264,8 +260,7 @@ int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inou
 // If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
 // ------------------------------------------------------------------------------------
 template<typename Real, typename ExceptionType = DeadlyImportError>
-inline
-const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) {
+inline const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) {
     Real f = 0;
 
     bool inv = (*c == '-');
@@ -354,8 +349,7 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
 // ------------------------------------------------------------------------------------
 // The same but more human.
 template<typename ExceptionType = DeadlyImportError>
-inline
-ai_real fast_atof(const char* c) {
+inline ai_real fast_atof(const char* c) {
     ai_real ret(0.0);
     fast_atoreal_move<ai_real, ExceptionType>(c, ret);
 
@@ -372,8 +366,7 @@ ai_real fast_atof( const char* c, const char** cout) {
 }
 
 template<typename ExceptionType = DeadlyImportError>
-inline
-ai_real fast_atof( const char** inout) {
+inline ai_real fast_atof( const char** inout) {
     ai_real ret(0.0);
     *inout = fast_atoreal_move<ai_real, ExceptionType>(*inout, ret);
 
diff --git a/D3D11Engine/include/assimp/importerdesc.h b/D3D11Engine/include/assimp/importerdesc.h
index 037f2e7a..d08bd178 100644
--- a/D3D11Engine/include/assimp/importerdesc.h
+++ b/D3D11Engine/include/assimp/importerdesc.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/light.h b/D3D11Engine/include/assimp/light.h
index f35f51e0..3331997a 100644
--- a/D3D11Engine/include/assimp/light.h
+++ b/D3D11Engine/include/assimp/light.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -255,5 +255,4 @@ struct aiLight {
 }
 #endif
 
-
 #endif // !! AI_LIGHT_H_INC
diff --git a/D3D11Engine/include/assimp/material.h b/D3D11Engine/include/assimp/material.h
index 4e55e489..80551e53 100644
--- a/D3D11Engine/include/assimp/material.h
+++ b/D3D11Engine/include/assimp/material.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -306,7 +306,7 @@ enum aiTextureType {
     aiTextureType_SHEEN = 19,
 
     /** Clearcoat
-    * Simulates a layer of 'polish' or 'laquer' layered on top of a PBR substrate
+    * Simulates a layer of 'polish' or 'lacquer' layered on top of a PBR substrate
     * https://autodesk.github.io/standard-surface/#closures/coating
     * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
     */
@@ -331,11 +331,11 @@ enum aiTextureType {
 #endif
 };
 
-#define AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN
+#define AI_TEXTURE_TYPE_MAX aiTextureType_TRANSMISSION
 
 // -------------------------------------------------------------------------------
 // Get a string for a given aiTextureType
-ASSIMP_API const char *TextureTypeToString(enum aiTextureType in);
+ASSIMP_API const char *aiTextureTypeToString(enum aiTextureType in);
 
 // ---------------------------------------------------------------------------
 /** @brief Defines all shading models supported by the library
@@ -989,6 +989,9 @@ extern "C" {
 // Roughness factor. 0.0 = Perfectly Smooth, 1.0 = Completely Rough
 #define AI_MATKEY_ROUGHNESS_FACTOR "$mat.roughnessFactor", 0, 0
 #define AI_MATKEY_ROUGHNESS_TEXTURE aiTextureType_DIFFUSE_ROUGHNESS, 0
+// Anisotropy factor. 0.0 = isotropic, 1.0 = anisotropy along tangent direction,
+// -1.0 = anisotropy along bitangent direction
+#define AI_MATKEY_ANISOTROPY_FACTOR "$mat.anisotropyFactor", 0, 0
 
 // Specular/Glossiness Workflow
 // ---------------------------
diff --git a/D3D11Engine/include/assimp/material.inl b/D3D11Engine/include/assimp/material.inl
index 693785c3..b7222f9c 100644
--- a/D3D11Engine/include/assimp/material.inl
+++ b/D3D11Engine/include/assimp/material.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,21 +44,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #pragma once
-#ifndef AI_MATERIAL_INL_INC
-#define AI_MATERIAL_INL_INC
 
 #ifdef __GNUC__
 #   pragma GCC system_header
 #endif
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiPropertyTypeInfo ai_real_to_property_type_info(float) {
+AI_FORCE_INLINE aiPropertyTypeInfo ai_real_to_property_type_info(float) {
 	return aiPTI_Float;
 }
 
-AI_FORCE_INLINE
-aiPropertyTypeInfo ai_real_to_property_type_info(double) {
+AI_FORCE_INLINE aiPropertyTypeInfo ai_real_to_property_type_info(double) {
 	return aiPTI_Double;
 }
 // ---------------------------------------------------------------------------
@@ -66,8 +62,7 @@ aiPropertyTypeInfo ai_real_to_property_type_info(double) {
 //! @cond never
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::GetTexture( aiTextureType type,
+AI_FORCE_INLINE aiReturn aiMaterial::GetTexture( aiTextureType type,
        unsigned int  index,
        C_STRUCT aiString* path,
        aiTextureMapping* mapping    /*= NULL*/,
@@ -79,15 +74,13 @@ aiReturn aiMaterial::GetTexture( aiTextureType type,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
+AI_FORCE_INLINE unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
     return ::aiGetMaterialTextureCount(this,type);
 }
 
 // ---------------------------------------------------------------------------
 template <typename Type>
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx, Type* pOut,
         unsigned int* pMax) const {
     unsigned int iNum = pMax ? *pMax : 1;
@@ -104,9 +97,12 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         if (prop->mType != aiPTI_Buffer) {
             return AI_FAILURE;
         }
-
-        iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
-        ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
+// std::min has in some cases a conflict with a defined min
+#ifdef min
+#   undef min
+#endif
+        iNum = static_cast<unsigned int>(std::min(static_cast<size_t>(iNum),prop->mDataLength / sizeof(Type)));
+        std::memcpy(pOut,prop->mData,iNum * sizeof(Type));
         if (pMax) {
             *pMax = iNum;
         }
@@ -116,8 +112,7 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
 
 // ---------------------------------------------------------------------------
 template <typename Type>
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx,Type& pOut) const {
     const aiMaterialProperty* prop;
     const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
@@ -137,6 +132,52 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
     return ret;
 }
 
+// ---------------------------------------------------------------------------
+// Specialisation for a single bool.
+// Casts floating point and integer to bool
+template <>
+AI_FORCE_INLINE
+        aiReturn
+        aiMaterial::Get(const char *pKey, unsigned int type,
+                unsigned int idx, bool &pOut) const {
+    const aiMaterialProperty *prop;
+    const aiReturn ret = ::aiGetMaterialProperty(this, pKey, type, idx,
+            (const aiMaterialProperty **)&prop);
+    if (AI_SUCCESS == ret) {
+
+        switch (prop->mType) {
+            // Type cannot be converted
+        default: return AI_FAILURE;
+
+        case aiPTI_Buffer: {
+            // Native bool value storage
+            if (prop->mDataLength < sizeof(bool)) {
+                return AI_FAILURE;
+            }
+            ::memcpy(&pOut, prop->mData, sizeof(bool));
+        } break;
+
+        case aiPTI_Float:
+        case aiPTI_Double: {
+            // Read as float and cast to bool
+            ai_real value = 0.0f;
+            if (AI_SUCCESS == ::aiGetMaterialFloat(this, pKey, type, idx, &value)) {
+                pOut = static_cast<bool>(value);
+                return AI_SUCCESS;
+            }
+            return AI_FAILURE;
+        }
+        case aiPTI_Integer: {
+            // Cast to bool
+            const int value = static_cast<int>(*prop->mData);
+            pOut = static_cast<bool>(value);
+            return AI_SUCCESS;
+        }
+        }
+    }
+    return ret;
+}
+
 // ---------------------------------------------------------------------------
 AI_FORCE_INLINE
 aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
@@ -145,27 +186,23 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
     return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx,int* pOut,
         unsigned int* pMax) const {
     return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx,ai_real& pOut) const {
     return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx,int& pOut) const {
     return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx,aiColor4D& pOut) const {
     return aiGetMaterialColor(this,pKey,type,idx,&pOut);
 }
@@ -174,7 +211,8 @@ AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
         unsigned int idx,aiColor3D& pOut) const {
     aiColor4D c;
     const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
-    pOut = aiColor3D(c.r,c.g,c.b);
+    if (ret == aiReturn_SUCCESS)
+        pOut = aiColor3D(c.r,c.g,c.b);
     return ret;
 }
 // ---------------------------------------------------------------------------
@@ -191,13 +229,9 @@ AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
 // ---------------------------------------------------------------------------
 template<class TYPE>
 aiReturn aiMaterial::AddProperty (const TYPE* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
-    return AddBinaryProperty((const void*)pInput,
-        pNumValues * sizeof(TYPE),
+        const unsigned int pNumValues, const char* pKey, unsigned int type,
+        unsigned int index) {
+    return AddBinaryProperty((const void*)pInput, pNumValues * sizeof(TYPE),
         pKey,type,index,aiPTI_Buffer);
 }
 
@@ -213,8 +247,7 @@ AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const float* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const double* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const double* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -225,8 +258,7 @@ aiReturn aiMaterial::AddProperty(const double* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -237,8 +269,7 @@ aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -249,8 +280,7 @@ aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -261,8 +291,7 @@ aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -273,8 +302,7 @@ aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const int* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const int* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -293,8 +321,7 @@ aiReturn aiMaterial::AddProperty(const int* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<float>(const float* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<float>(const float* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -306,8 +333,7 @@ aiReturn aiMaterial::AddProperty<float>(const float* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<double>(const double* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<double>(const double* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -319,8 +345,7 @@ aiReturn aiMaterial::AddProperty<double>(const double* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -332,8 +357,7 @@ aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -345,8 +369,7 @@ aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -358,8 +381,7 @@ aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -371,8 +393,7 @@ aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<int>(const int* pInput,
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<int>(const int* pInput,
         const unsigned int pNumValues,
         const char* pKey,
         unsigned int type,
@@ -383,5 +404,3 @@ aiReturn aiMaterial::AddProperty<int>(const int* pInput,
 }
 
 //! @endcond
-
-#endif //! AI_MATERIAL_INL_INC
diff --git a/D3D11Engine/include/assimp/matrix3x3.h b/D3D11Engine/include/assimp/matrix3x3.h
index c941d9f9..74382e26 100644
--- a/D3D11Engine/include/assimp/matrix3x3.h
+++ b/D3D11Engine/include/assimp/matrix3x3.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -95,7 +95,7 @@ class aiMatrix3x3t {
     bool operator== (const aiMatrix3x3t<TReal>& m) const;
     bool operator!= (const aiMatrix3x3t<TReal>& m) const;
 
-    bool Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix3x3t<TReal> &m, TReal epsilon = ai_epsilon) const;
 
     template <typename TOther>
     operator aiMatrix3x3t<TOther> () const;
diff --git a/D3D11Engine/include/assimp/matrix3x3.inl b/D3D11Engine/include/assimp/matrix3x3.inl
index eee6d061..99d9197e 100644
--- a/D3D11Engine/include/assimp/matrix3x3.inl
+++ b/D3D11Engine/include/assimp/matrix3x3.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/matrix4x4.h b/D3D11Engine/include/assimp/matrix4x4.h
index 6caf7686..67e0e356 100644
--- a/D3D11Engine/include/assimp/matrix4x4.h
+++ b/D3D11Engine/include/assimp/matrix4x4.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -110,7 +110,7 @@ class aiMatrix4x4t {
     bool operator== (const aiMatrix4x4t& m) const;
     bool operator!= (const aiMatrix4x4t& m) const;
 
-    bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix4x4t &m, TReal epsilon = ai_epsilon) const;
 
     // matrix multiplication.
     aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
diff --git a/D3D11Engine/include/assimp/matrix4x4.inl b/D3D11Engine/include/assimp/matrix4x4.inl
index c1dd87b6..54d176d1 100644
--- a/D3D11Engine/include/assimp/matrix4x4.inl
+++ b/D3D11Engine/include/assimp/matrix4x4.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/D3D11Engine/include/assimp/mesh.h b/D3D11Engine/include/assimp/mesh.h
index 42312a2c..3ef94e60 100644
--- a/D3D11Engine/include/assimp/mesh.h
+++ b/D3D11Engine/include/assimp/mesh.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2023, assimp team
 
 All rights reserved.
 
@@ -111,7 +111,8 @@ extern "C" {
 #endif // !! AI_MAX_NUMBER_OF_TEXTURECOORDS
 
 // ---------------------------------------------------------------------------
-/** @brief A single face in a mesh, referring to multiple vertices.
+/**
+ * @brief A single face in a mesh, referring to multiple vertices.
  *
  * If mNumIndices is 3, we call the face 'triangle', for mNumIndices > 3
  * it's called 'polygon' (hey, that's just a definition!).
@@ -120,7 +121,7 @@ extern "C" {
  * primitive are actually present in a mesh. The #aiProcess_SortByPType flag
  * executes a special post-processing algorithm which splits meshes with
  * *different* primitive types mixed up (e.g. lines and triangles) in several
- * 'clean' submeshes. Furthermore there is a configuration option (
+ * 'clean' sub-meshes. Furthermore there is a configuration option (
  * #AI_CONFIG_PP_SBP_REMOVE) to force #aiProcess_SortByPType to remove
  * specific kinds of primitives from the imported scene, completely and forever.
  * In many cases you'll probably want to set this setting to
@@ -142,25 +143,25 @@ struct aiFace {
 
 #ifdef __cplusplus
 
-    //! Default constructor
+    //! @brief Default constructor.
     aiFace() AI_NO_EXCEPT
             : mNumIndices(0),
               mIndices(nullptr) {
         // empty
     }
 
-    //! Default destructor. Delete the index array
+    //! @brief Default destructor. Delete the index array
     ~aiFace() {
         delete[] mIndices;
     }
 
-    //! Copy constructor. Copy the index array
+    //! @brief Copy constructor. Copy the index array
     aiFace(const aiFace &o) :
             mNumIndices(0), mIndices(nullptr) {
         *this = o;
     }
 
-    //! Assignment operator. Copy the index array
+    //! @brief Assignment operator. Copy the index array
     aiFace &operator=(const aiFace &o) {
         if (&o == this) {
             return *this;
@@ -178,8 +179,7 @@ struct aiFace {
         return *this;
     }
 
-    //! Comparison operator. Checks whether the index array
-    //! of two faces is identical
+    //! @brief Comparison operator. Checks whether the index array of two faces is identical.
     bool operator==(const aiFace &o) const {
         if (mIndices == o.mIndices) {
             return true;
@@ -202,7 +202,7 @@ struct aiFace {
         return true;
     }
 
-    //! Inverse comparison operator. Checks whether the index
+    //! @brief Inverse comparison operator. Checks whether the index
     //! array of two faces is NOT identical
     bool operator!=(const aiFace &o) const {
         return !(*this == o);
@@ -223,14 +223,14 @@ struct aiVertexWeight {
 
 #ifdef __cplusplus
 
-    //! Default constructor
+    //! @brief Default constructor
     aiVertexWeight() AI_NO_EXCEPT
             : mVertexId(0),
               mWeight(0.0f) {
         // empty
     }
 
-    //! Initialization from a given index and vertex weight factor
+    //! @brief Initialization from a given index and vertex weight factor
     //! \param pID ID
     //! \param pWeight Vertex weight factor
     aiVertexWeight(unsigned int pID, float pWeight) :
@@ -261,27 +261,38 @@ struct aiNode;
  *  position of the bone at the time of binding.
  */
 struct aiBone {
-    //! The name of the bone.
+    /**
+     * The name of the bone.
+     */
     C_STRUCT aiString mName;
 
-    //! The number of vertices affected by this bone.
-    //! The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
+    /**
+     * The number of vertices affected by this bone.
+     * The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
+     */
     unsigned int mNumWeights;
 
 #ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
-    // The bone armature node - used for skeleton conversion
-    // you must enable aiProcess_PopulateArmatureData to populate this
+    /**
+     * The bone armature node - used for skeleton conversion
+     * you must enable aiProcess_PopulateArmatureData to populate this
+     */
     C_STRUCT aiNode *mArmature;
 
-    // The bone node in the scene - used for skeleton conversion
-    // you must enable aiProcess_PopulateArmatureData to populate this
+    /**
+     * The bone node in the scene - used for skeleton conversion
+     * you must enable aiProcess_PopulateArmatureData to populate this
+     */
     C_STRUCT aiNode *mNode;
 
 #endif
-    //! The influence weights of this bone, by vertex index.
+    /**
+     * The influence weights of this bone, by vertex index.
+     */
     C_STRUCT aiVertexWeight *mWeights;
 
-    /** Matrix that transforms from bone space to mesh space in bind pose.
+    /**
+     * Matrix that transforms from mesh space to bone space in bind pose.
      *
      * This matrix describes the position of the mesh
      * in the local space of this bone when the skeleton was bound.
@@ -296,7 +307,7 @@ struct aiBone {
 
 #ifdef __cplusplus
 
-    //! Default constructor
+    ///	@brief  Default constructor
     aiBone() AI_NO_EXCEPT
             : mName(),
               mNumWeights(0),
@@ -309,7 +320,7 @@ struct aiBone {
         // empty
     }
 
-    //! Copy constructor
+    /// @brief  Copy constructor
     aiBone(const aiBone &other) :
             mName(other.mName),
             mNumWeights(other.mNumWeights),
@@ -319,14 +330,27 @@ struct aiBone {
 #endif
             mWeights(nullptr),
             mOffsetMatrix(other.mOffsetMatrix) {
-        if (other.mWeights && other.mNumWeights) {
-            mWeights = new aiVertexWeight[mNumWeights];
-            ::memcpy(mWeights, other.mWeights, mNumWeights * sizeof(aiVertexWeight));
+        copyVertexWeights(other);
+    }
+
+    void copyVertexWeights( const aiBone &other ) {
+        if (other.mWeights == nullptr || other.mNumWeights == 0) {
+            mWeights = nullptr;
+            mNumWeights = 0;
+            return;
+        }
+
+        mNumWeights = other.mNumWeights;
+        if (mWeights) {
+            delete[] mWeights;
         }
+
+        mWeights = new aiVertexWeight[mNumWeights];
+        ::memcpy(mWeights, other.mWeights, mNumWeights * sizeof(aiVertexWeight));
     }
 
-    //! Assignment operator
-    aiBone &operator=(const aiBone &other) {
+    //! @brief Assignment operator
+    aiBone &operator = (const aiBone &other) {
         if (this == &other) {
             return *this;
         }
@@ -334,21 +358,14 @@ struct aiBone {
         mName = other.mName;
         mNumWeights = other.mNumWeights;
         mOffsetMatrix = other.mOffsetMatrix;
-
-        if (other.mWeights && other.mNumWeights) {
-            if (mWeights) {
-                delete[] mWeights;
-            }
-
-            mWeights = new aiVertexWeight[mNumWeights];
-            ::memcpy(mWeights, other.mWeights, mNumWeights * sizeof(aiVertexWeight));
-        }
+        copyVertexWeights(other);
 
         return *this;
     }
 
+    /// @brief Compare operator.
     bool operator==(const aiBone &rhs) const {
-        if (mName != rhs.mName || mNumWeights != rhs.mNumWeights) {
+        if (mName != rhs.mName || mNumWeights != rhs.mNumWeights ) {
             return false;
         }
 
@@ -360,7 +377,7 @@ struct aiBone {
 
         return true;
     }
-    //! Destructor - deletes the array of vertex weights
+    //! @brief Destructor - deletes the array of vertex weights
     ~aiBone() {
         delete[] mWeights;
     }
@@ -376,27 +393,31 @@ struct aiBone {
  *  @see AI_CONFIG_PP_SBP_REMOVE Removal of specific primitive types.
  */
 enum aiPrimitiveType {
-    /** A point primitive.
+    /**
+     * @brief A point primitive.
      *
      * This is just a single vertex in the virtual world,
      * #aiFace contains just one index for such a primitive.
      */
     aiPrimitiveType_POINT = 0x1,
 
-    /** A line primitive.
+    /**
+     * @brief A line primitive.
      *
      * This is a line defined through a start and an end position.
      * #aiFace contains exactly two indices for such a primitive.
      */
     aiPrimitiveType_LINE = 0x2,
 
-    /** A triangular primitive.
+    /**
+     * @brief A triangular primitive.
      *
      * A triangle consists of three indices.
      */
     aiPrimitiveType_TRIANGLE = 0x4,
 
-    /** A higher-level polygon with more than 3 edges.
+    /**
+     * @brief A higher-level polygon with more than 3 edges.
      *
      * A triangle is a polygon, but polygon in this context means
      * "all polygons that are not triangles". The "Triangulate"-Step
@@ -406,7 +427,7 @@ enum aiPrimitiveType {
     aiPrimitiveType_POLYGON = 0x8,
 
     /**
-     * A flag to determine whether this triangles only mesh is NGON encoded.
+     * @brief A flag to determine whether this triangles only mesh is NGON encoded.
      *
      * NGON encoding is a special encoding that tells whether 2 or more consecutive triangles
      * should be considered as a triangle fan. This is identified by looking at the first vertex index.
@@ -423,8 +444,9 @@ enum aiPrimitiveType {
      */
     aiPrimitiveType_NGONEncodingFlag = 0x10,
 
-/** This value is not used. It is just here to force the
-     *  compiler to map this enum to a 32 Bit integer.
+    /**
+     * This value is not used. It is just here to force the
+     * compiler to map this enum to a 32 Bit integer.
      */
 #ifndef SWIG
     _aiPrimitiveType_Force32Bit = INT_MAX
@@ -489,25 +511,20 @@ struct aiAnimMesh {
     float mWeight;
 
 #ifdef __cplusplus
-
-    aiAnimMesh() AI_NO_EXCEPT
-            : mVertices(nullptr),
-              mNormals(nullptr),
-              mTangents(nullptr),
-              mBitangents(nullptr),
-              mColors(),
-              mTextureCoords(),
-              mNumVertices(0),
-              mWeight(0.0f) {
-        // fixme consider moving this to the ctor initializer list as well
-        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
-            mTextureCoords[a] = nullptr;
-        }
-        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
-            mColors[a] = nullptr;
-        }
+    /// @brief  The class constructor.
+    aiAnimMesh() AI_NO_EXCEPT :
+            mVertices(nullptr),
+            mNormals(nullptr),
+            mTangents(nullptr),
+            mBitangents(nullptr),
+            mColors {nullptr},
+            mTextureCoords{nullptr},
+            mNumVertices(0),
+            mWeight(0.0f) {
+        // empty
     }
 
+    /// @brief The class destructor.
     ~aiAnimMesh() {
         delete[] mVertices;
         delete[] mNormals;
@@ -521,35 +538,51 @@ struct aiAnimMesh {
         }
     }
 
-    /** Check whether the anim mesh overrides the vertex positions
-     *  of its host mesh*/
+    /**
+     *  @brief Check whether the anim-mesh overrides the vertex positions
+     *         of its host mesh.
+     *  @return true if positions are stored, false if not.
+     */
     bool HasPositions() const {
         return mVertices != nullptr;
     }
 
-    /** Check whether the anim mesh overrides the vertex normals
-     *  of its host mesh*/
+    /**
+     *  @brief Check whether the anim-mesh overrides the vertex normals
+     *         of its host mesh
+     *  @return true if normals are stored, false if not.
+     */
     bool HasNormals() const {
         return mNormals != nullptr;
     }
 
-    /** Check whether the anim mesh overrides the vertex tangents
-     *  and bitangents of its host mesh. As for aiMesh,
-     *  tangents and bitangents always go together. */
+    /**
+     *  @brief Check whether the anim-mesh overrides the vertex tangents
+     *         and bitangents of its host mesh. As for aiMesh,
+     *         tangents and bitangents always go together.
+     *  @return true if tangents and bi-tangents are stored, false if not.
+     */
     bool HasTangentsAndBitangents() const {
         return mTangents != nullptr;
     }
 
-    /** Check whether the anim mesh overrides a particular
-     * set of vertex colors on his host mesh.
-     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS */
+    /**
+     *  @brief Check whether the anim mesh overrides a particular
+     *         set of vertex colors on his host mesh.
+     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS
+     *  @return true if vertex colors are stored, false if not.
+     */
+
     bool HasVertexColors(unsigned int pIndex) const {
         return pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS ? false : mColors[pIndex] != nullptr;
     }
 
-    /** Check whether the anim mesh overrides a particular
-     * set of texture coordinates on his host mesh.
-     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS */
+    /**
+     *  @brief Check whether the anim mesh overrides a particular
+     *        set of texture coordinates on his host mesh.
+     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS
+     *  @return true if texture coordinates are stored, false if not.
+     */
     bool HasTextureCoords(unsigned int pIndex) const {
         return pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? false : mTextureCoords[pIndex] != nullptr;
     }
@@ -561,6 +594,9 @@ struct aiAnimMesh {
 /** @brief Enumerates the methods of mesh morphing supported by Assimp.
  */
 enum aiMorphingMethod {
+    /** Morphing method to be determined */
+    aiMorphingMethod_UNKNOWN = 0x0,
+
     /** Interpolation between morph targets */
     aiMorphingMethod_VERTEX_BLEND = 0x1,
 
@@ -580,143 +616,167 @@ enum aiMorphingMethod {
 
 // ---------------------------------------------------------------------------
 /** @brief A mesh represents a geometry or model with a single material.
-*
-* It usually consists of a number of vertices and a series of primitives/faces
-* referencing the vertices. In addition there might be a series of bones, each
-* of them addressing a number of vertices with a certain weight. Vertex data
-* is presented in channels with each channel containing a single per-vertex
-* information such as a set of texture coordinates or a normal vector.
-* If a data pointer is non-null, the corresponding data stream is present.
-* From C++-programs you can also use the comfort functions Has*() to
-* test for the presence of various data streams.
-*
-* A Mesh uses only a single material which is referenced by a material ID.
-* @note The mPositions member is usually not optional. However, vertex positions
-* *could* be missing if the #AI_SCENE_FLAGS_INCOMPLETE flag is set in
-* @code
-* aiScene::mFlags
-* @endcode
-*/
+ *
+ * It usually consists of a number of vertices and a series of primitives/faces
+ * referencing the vertices. In addition there might be a series of bones, each
+ * of them addressing a number of vertices with a certain weight. Vertex data
+ * is presented in channels with each channel containing a single per-vertex
+ * information such as a set of texture coordinates or a normal vector.
+ * If a data pointer is non-null, the corresponding data stream is present.
+ * From C++-programs you can also use the comfort functions Has*() to
+ * test for the presence of various data streams.
+ *
+ * A Mesh uses only a single material which is referenced by a material ID.
+ * @note The mPositions member is usually not optional. However, vertex positions
+ * *could* be missing if the #AI_SCENE_FLAGS_INCOMPLETE flag is set in
+ * @code
+ * aiScene::mFlags
+ * @endcode
+ */
 struct aiMesh {
-    /** Bitwise combination of the members of the #aiPrimitiveType enum.
+    /**
+     * Bitwise combination of the members of the #aiPrimitiveType enum.
      * This specifies which types of primitives are present in the mesh.
      * The "SortByPrimitiveType"-Step can be used to make sure the
      * output meshes consist of one primitive type each.
      */
     unsigned int mPrimitiveTypes;
 
-    /** The number of vertices in this mesh.
-    * This is also the size of all of the per-vertex data arrays.
-    * The maximum value for this member is #AI_MAX_VERTICES.
-    */
+    /**
+     * The number of vertices in this mesh.
+     * This is also the size of all of the per-vertex data arrays.
+     * The maximum value for this member is #AI_MAX_VERTICES.
+     */
     unsigned int mNumVertices;
 
-    /** The number of primitives (triangles, polygons, lines) in this  mesh.
-    * This is also the size of the mFaces array.
-    * The maximum value for this member is #AI_MAX_FACES.
-    */
+    /**
+     * The number of primitives (triangles, polygons, lines) in this  mesh.
+     * This is also the size of the mFaces array.
+     * The maximum value for this member is #AI_MAX_FACES.
+     */
     unsigned int mNumFaces;
 
-    /** Vertex positions.
-    * This array is always present in a mesh. The array is
-    * mNumVertices in size.
-    */
+    /**
+     * @brief Vertex positions.
+     * 
+     * This array is always present in a mesh. The array is
+     * mNumVertices in size.
+     */
     C_STRUCT aiVector3D *mVertices;
 
-    /** Vertex normals.
-    * The array contains normalized vectors, nullptr if not present.
-    * The array is mNumVertices in size. Normals are undefined for
-    * point and line primitives. A mesh consisting of points and
-    * lines only may not have normal vectors. Meshes with mixed
-    * primitive types (i.e. lines and triangles) may have normals,
-    * but the normals for vertices that are only referenced by
-    * point or line primitives are undefined and set to QNaN (WARN:
-    * qNaN compares to inequal to *everything*, even to qNaN itself.
-    * Using code like this to check whether a field is qnan is:
-    * @code
-    * #define IS_QNAN(f) (f != f)
-    * @endcode
-    * still dangerous because even 1.f == 1.f could evaluate to false! (
-    * remember the subtleties of IEEE754 artithmetics). Use stuff like
-    * @c fpclassify instead.
-    * @note Normal vectors computed by Assimp are always unit-length.
-    * However, this needn't apply for normals that have been taken
-    *   directly from the model file.
-    */
+    /**
+     * @brief Vertex normals.
+     * 
+     * The array contains normalized vectors, nullptr if not present.
+     * The array is mNumVertices in size. Normals are undefined for
+     * point and line primitives. A mesh consisting of points and
+     * lines only may not have normal vectors. Meshes with mixed
+     * primitive types (i.e. lines and triangles) may have normals,
+     * but the normals for vertices that are only referenced by
+     * point or line primitives are undefined and set to QNaN (WARN:
+     * qNaN compares to inequal to *everything*, even to qNaN itself.
+     * Using code like this to check whether a field is qnan is:
+     * @code
+     * #define IS_QNAN(f) (f != f)
+     * @endcode
+     * still dangerous because even 1.f == 1.f could evaluate to false! (
+     * remember the subtleties of IEEE754 artithmetics). Use stuff like
+     * @c fpclassify instead.
+     * @note Normal vectors computed by Assimp are always unit-length.
+     * However, this needn't apply for normals that have been taken
+     * directly from the model file.
+     */
     C_STRUCT aiVector3D *mNormals;
 
-    /** Vertex tangents.
-    * The tangent of a vertex points in the direction of the positive
-    * X texture axis. The array contains normalized vectors, nullptr if
-    * not present. The array is mNumVertices in size. A mesh consisting
-    * of points and lines only may not have normal vectors. Meshes with
-    * mixed primitive types (i.e. lines and triangles) may have
-    * normals, but the normals for vertices that are only referenced by
-    * point or line primitives are undefined and set to qNaN.  See
-    * the #mNormals member for a detailed discussion of qNaNs.
-    * @note If the mesh contains tangents, it automatically also
-    * contains bitangents.
-    */
+    /**
+     * @brief Vertex tangents.
+     * 
+     * The tangent of a vertex points in the direction of the positive
+     * X texture axis. The array contains normalized vectors, nullptr if
+     * not present. The array is mNumVertices in size. A mesh consisting
+     * of points and lines only may not have normal vectors. Meshes with
+     * mixed primitive types (i.e. lines and triangles) may have
+     * normals, but the normals for vertices that are only referenced by
+     * point or line primitives are undefined and set to qNaN.  See
+     * the #mNormals member for a detailed discussion of qNaNs.
+     * @note If the mesh contains tangents, it automatically also
+     * contains bitangents.
+     */
     C_STRUCT aiVector3D *mTangents;
 
-    /** Vertex bitangents.
-    * The bitangent of a vertex points in the direction of the positive
-    * Y texture axis. The array contains normalized vectors, nullptr if not
-    * present. The array is mNumVertices in size.
-    * @note If the mesh contains tangents, it automatically also contains
-    * bitangents.
-    */
+    /**
+     * @brief Vertex bitangents.
+     * 
+     * The bitangent of a vertex points in the direction of the positive
+     * Y texture axis. The array contains normalized vectors, nullptr if not
+     * present. The array is mNumVertices in size.
+     * @note If the mesh contains tangents, it automatically also contains
+     * bitangents.
+     */
     C_STRUCT aiVector3D *mBitangents;
 
-    /** Vertex color sets.
-    * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
-    * colors per vertex. nullptr if not present. Each array is
-    * mNumVertices in size if present.
-    */
+    /**
+     * @brief Vertex color sets.
+     * 
+     * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
+     * colors per vertex. nullptr if not present. Each array is
+     * mNumVertices in size if present.
+     */
     C_STRUCT aiColor4D *mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
 
-    /** Vertex texture coordinates, also known as UV channels.
-    * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
-    * vertex. nullptr if not present. The array is mNumVertices in size.
-    */
+    /**
+     * @brief Vertex texture coordinates, also known as UV channels.
+     * 
+     * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
+     * vertex. nullptr if not present. The array is mNumVertices in size.
+     */
     C_STRUCT aiVector3D *mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
-    /** Specifies the number of components for a given UV channel.
-    * Up to three channels are supported (UVW, for accessing volume
-    * or cube maps). If the value is 2 for a given channel n, the
-    * component p.z of mTextureCoords[n][p] is set to 0.0f.
-    * If the value is 1 for a given channel, p.y is set to 0.0f, too.
-    * @note 4D coordinates are not supported
-    */
+    /**
+     * @brief Specifies the number of components for a given UV channel.
+     * 
+     * Up to three channels are supported (UVW, for accessing volume
+     * or cube maps). If the value is 2 for a given channel n, the
+     * component p.z of mTextureCoords[n][p] is set to 0.0f.
+     * If the value is 1 for a given channel, p.y is set to 0.0f, too.
+     * @note 4D coordinates are not supported
+     */
     unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
-    /** The faces the mesh is constructed from.
-    * Each face refers to a number of vertices by their indices.
-    * This array is always present in a mesh, its size is given
-    * in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
-    * is NOT set each face references an unique set of vertices.
-    */
+    /**
+     * @brief The faces the mesh is constructed from.
+     * 
+     * Each face refers to a number of vertices by their indices.
+     * This array is always present in a mesh, its size is given
+     *  in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
+     * is NOT set each face references an unique set of vertices.
+     */
     C_STRUCT aiFace *mFaces;
 
-    /** The number of bones this mesh contains.
-    * Can be 0, in which case the mBones array is nullptr.
+    /**
+    * The number of bones this mesh contains. Can be 0, in which case the mBones array is nullptr.
     */
     unsigned int mNumBones;
 
-    /** The bones of this mesh.
-    * A bone consists of a name by which it can be found in the
-    * frame hierarchy and a set of vertex weights.
-    */
+    /**
+     * @brief The bones of this mesh.
+     * 
+     * A bone consists of a name by which it can be found in the
+     * frame hierarchy and a set of vertex weights.
+     */
     C_STRUCT aiBone **mBones;
 
-    /** The material used by this mesh.
+    /**
+     * @brief The material used by this mesh.
+     * 
      * A mesh uses only a single material. If an imported model uses
      * multiple materials, the import splits up the mesh. Use this value
      * as index into the scene's material list.
      */
     unsigned int mMaterialIndex;
 
-    /** Name of the mesh. Meshes can be named, but this is not a
+    /**
+     *  Name of the mesh. Meshes can be named, but this is not a
      *  requirement and leaving this field empty is totally fine.
      *  There are mainly three uses for mesh names:
      *   - some formats name nodes and meshes independently.
@@ -726,35 +786,46 @@ struct aiMesh {
      *      aids the caller at recovering the original mesh
      *      partitioning.
      *   - Vertex animations refer to meshes by their names.
-     **/
+     */
     C_STRUCT aiString mName;
 
-    /** The number of attachment meshes. Note! Currently only works with Collada loader. */
+    /**
+     * The number of attachment meshes.
+     * Currently known to work with loaders:
+     * - Collada
+     * - gltf
+     */
     unsigned int mNumAnimMeshes;
 
-    /** Attachment meshes for this mesh, for vertex-based animation.
-     *  Attachment meshes carry replacement data for some of the
-     *  mesh'es vertex components (usually positions, normals).
-     *  Note! Currently only works with Collada loader.*/
+    /**
+     * Attachment meshes for this mesh, for vertex-based animation.
+     * Attachment meshes carry replacement data for some of the
+     * mesh'es vertex components (usually positions, normals).
+     * Currently known to work with loaders:
+     * - Collada
+     * - gltf
+     */
     C_STRUCT aiAnimMesh **mAnimMeshes;
 
     /**
      *  Method of morphing when anim-meshes are specified.
+     *  @see aiMorphingMethod to learn more about the provided morphing targets.
      */
-    unsigned int mMethod;
+    enum aiMorphingMethod mMethod;
 
     /**
      *  The bounding box.
      */
     C_STRUCT aiAABB mAABB;
 
-    /** Vertex UV stream names. Pointer to array of size AI_MAX_NUMBER_OF_TEXTURECOORDS
+    /**
+     * Vertex UV stream names. Pointer to array of size AI_MAX_NUMBER_OF_TEXTURECOORDS
      */
     C_STRUCT aiString **mTextureCoordsNames;
 
 #ifdef __cplusplus
 
-    //! Default constructor. Initializes all members to 0
+    //! The default class constructor.
     aiMesh() AI_NO_EXCEPT
             : mPrimitiveTypes(0),
               mNumVertices(0),
@@ -763,29 +834,22 @@ struct aiMesh {
               mNormals(nullptr),
               mTangents(nullptr),
               mBitangents(nullptr),
-              mColors(),
-              mTextureCoords(),
-              mNumUVComponents(),
+              mColors{nullptr},
+              mTextureCoords{nullptr},
+              mNumUVComponents{0},
               mFaces(nullptr),
               mNumBones(0),
               mBones(nullptr),
               mMaterialIndex(0),
               mNumAnimMeshes(0),
               mAnimMeshes(nullptr),
-              mMethod(0),
+              mMethod(aiMorphingMethod_UNKNOWN),
               mAABB(),
               mTextureCoordsNames(nullptr) {
-        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
-            mNumUVComponents[a] = 0;
-            mTextureCoords[a] = nullptr;
-        }
-
-        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
-            mColors[a] = nullptr;
-        }
+        // empty
     }
 
-    //! Deletes all storage allocated for the mesh
+    //! @brief The class destructor.
     ~aiMesh() {
         delete[] mVertices;
         delete[] mNormals;
@@ -826,44 +890,58 @@ struct aiMesh {
         delete[] mFaces;
     }
 
-    //! Check whether the mesh contains positions. Provided no special
-    //! scene flags are set, this will always be true
-    bool HasPositions() const { return mVertices != nullptr && mNumVertices > 0; }
+    //! @brief Check whether the mesh contains positions. Provided no special
+    //!        scene flags are set, this will always be true
+    //! @return true, if positions are stored, false if not.
+    bool HasPositions() const {
+        return mVertices != nullptr && mNumVertices > 0;
+    }
 
-    //! Check whether the mesh contains faces. If no special scene flags
-    //! are set this should always return true
-    bool HasFaces() const { return mFaces != nullptr && mNumFaces > 0; }
+    //! @brief Check whether the mesh contains faces. If no special scene flags
+    //!        are set this should always return true
+    //! @return true, if faces are stored, false if not.
+    bool HasFaces() const {
+        return mFaces != nullptr && mNumFaces > 0;
+    }
 
-    //! Check whether the mesh contains normal vectors
-    bool HasNormals() const { return mNormals != nullptr && mNumVertices > 0; }
+    //! @brief Check whether the mesh contains normal vectors
+    //! @return true, if normals are stored, false if not.
+    bool HasNormals() const {
+        return mNormals != nullptr && mNumVertices > 0;
+    }
 
-    //! Check whether the mesh contains tangent and bitangent vectors
+    //! @brief Check whether the mesh contains tangent and bitangent vectors.
+    //! 
     //! It is not possible that it contains tangents and no bitangents
     //! (or the other way round). The existence of one of them
     //! implies that the second is there, too.
-    bool HasTangentsAndBitangents() const { return mTangents != nullptr && mBitangents != nullptr && mNumVertices > 0; }
+    //! @return true, if tangents and bi-tangents are stored, false if not.
+    bool HasTangentsAndBitangents() const {
+        return mTangents != nullptr && mBitangents != nullptr && mNumVertices > 0;
+    }
 
-    //! Check whether the mesh contains a vertex color set
-    //! \param pIndex Index of the vertex color set
-    bool HasVertexColors(unsigned int pIndex) const {
-        if (pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS) {
+    //! @brief Check whether the mesh contains a vertex color set
+    //! @param index    Index of the vertex color set
+    //! @return true, if vertex colors are stored, false if not.
+    bool HasVertexColors(unsigned int index) const {
+        if (index >= AI_MAX_NUMBER_OF_COLOR_SETS) {
             return false;
-        } else {
-            return mColors[pIndex] != nullptr && mNumVertices > 0;
         }
+        return mColors[index] != nullptr && mNumVertices > 0;        
     }
 
-    //! Check whether the mesh contains a texture coordinate set
-    //! \param pIndex Index of the texture coordinates set
-    bool HasTextureCoords(unsigned int pIndex) const {
-        if (pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+    //! @brief Check whether the mesh contains a texture coordinate set
+    //! @param index    Index of the texture coordinates set
+    //! @return true, if texture coordinates are stored, false if not.
+    bool HasTextureCoords(unsigned int index) const {
+        if (index >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
             return false;
-        } else {
-            return mTextureCoords[pIndex] != nullptr && mNumVertices > 0;
         }
+        return (mTextureCoords[index] != nullptr && mNumVertices > 0);
     }
 
-    //! Get the number of UV channels the mesh contains
+    //! @brief Get the number of UV channels the mesh contains.
+    //! @return the number of stored uv-channels.
     unsigned int GetNumUVChannels() const {
         unsigned int n(0);
         while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n]) {
@@ -873,7 +951,8 @@ struct aiMesh {
         return n;
     }
 
-    //! Get the number of vertex color channels the mesh contains
+    //! @brief Get the number of vertex color channels the mesh contains.
+    //! @return The number of stored color channels.
     unsigned int GetNumColorChannels() const {
         unsigned int n(0);
         while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n]) {
@@ -882,13 +961,15 @@ struct aiMesh {
         return n;
     }
 
-    //! Check whether the mesh contains bones
+    //! @brief Check whether the mesh contains bones.
+    //! @return true, if bones are stored.
     bool HasBones() const {
         return mBones != nullptr && mNumBones > 0;
     }
 
-    //! Check whether the mesh contains a texture coordinate set name
-    //! \param pIndex Index of the texture coordinates set
+    //! @brief  Check whether the mesh contains a texture coordinate set name
+    //! @param pIndex Index of the texture coordinates set
+    //! @return true, if texture coordinates for the index exists.
     bool HasTextureCoordsName(unsigned int pIndex) const {
         if (mTextureCoordsNames == nullptr || pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
             return false;
@@ -896,9 +977,9 @@ struct aiMesh {
         return mTextureCoordsNames[pIndex] != nullptr;
     }
 
-    //! Set a texture coordinate set name
-    //! \param pIndex Index of the texture coordinates set
-    //! \param texCoordsName name of the texture coordinate set
+    //! @brief  Set a texture coordinate set name
+    //! @param pIndex Index of the texture coordinates set
+    //! @param texCoordsName name of the texture coordinate set
     void SetTextureCoordsName(unsigned int pIndex, const aiString &texCoordsName) {
         if (pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
             return;
@@ -906,7 +987,10 @@ struct aiMesh {
 
         if (mTextureCoordsNames == nullptr) {
             // Construct and null-init array
-            mTextureCoordsNames = new aiString *[AI_MAX_NUMBER_OF_TEXTURECOORDS] {};
+            mTextureCoordsNames = new aiString *[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+            for (size_t i=0; i<AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                mTextureCoordsNames[i] = nullptr;
+            }
         }
 
         if (texCoordsName.length == 0) {
@@ -923,20 +1007,162 @@ struct aiMesh {
         *mTextureCoordsNames[pIndex] = texCoordsName;
     }
 
-    //! Get a texture coordinate set name
-    //! \param pIndex Index of the texture coordinates set
-    const aiString *GetTextureCoordsName(unsigned int pIndex) const {
-        if (mTextureCoordsNames == nullptr || pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+    //! @brief  Get a texture coordinate set name
+    //! @param  pIndex Index of the texture coordinates set
+    //! @return The texture coordinate name.
+    const aiString *GetTextureCoordsName(unsigned int index) const {
+        if (mTextureCoordsNames == nullptr || index >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
             return nullptr;
         }
 
-        return mTextureCoordsNames[pIndex];
+        return mTextureCoordsNames[index];
     }
 
 #endif // __cplusplus
 };
 
+/**
+ * @brief  A skeleton bone represents a single bone is a skeleton structure.
+ *
+ * Skeleton-Animations can be represented via a skeleton struct, which describes
+ * a hierarchical tree assembled from skeleton bones. A bone is linked to a mesh.
+ * The bone knows its parent bone. If there is no parent bone the parent id is
+ * marked with -1.
+ * The skeleton-bone stores a pointer to its used armature. If there is no
+ * armature this value if set to nullptr.
+ * A skeleton bone stores its offset-matrix, which is the absolute transformation
+ * for the bone. The bone stores the locale transformation to its parent as well.
+ * You can compute the offset matrix by multiplying the hierarchy like:
+ * Tree: s1 -> s2 -> s3
+ * Offset-Matrix s3 = locale-s3 * locale-s2 * locale-s1
+ */
+struct aiSkeletonBone {
+    /// The parent bone index, is -1 one if this bone represents the root bone.
+    int mParent;
+
+
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+    /// @brief The bone armature node - used for skeleton conversion
+    /// you must enable aiProcess_PopulateArmatureData to populate this
+    C_STRUCT aiNode *mArmature;
+
+    /// @brief The bone node in the scene - used for skeleton conversion
+    /// you must enable aiProcess_PopulateArmatureData to populate this
+    C_STRUCT aiNode *mNode;
+
+#endif
+    /// @brief The number of weights
+    unsigned int mNumnWeights;
+
+    /// The mesh index, which will get influenced by the weight.
+    C_STRUCT aiMesh *mMeshId;
+
+    /// The influence weights of this bone, by vertex index.
+    C_STRUCT aiVertexWeight *mWeights;
+
+    /** Matrix that transforms from bone space to mesh space in bind pose.
+     *
+     * This matrix describes the position of the mesh
+     * in the local space of this bone when the skeleton was bound.
+     * Thus it can be used directly to determine a desired vertex position,
+     * given the world-space transform of the bone when animated,
+     * and the position of the vertex in mesh space.
+     *
+     * It is sometimes called an inverse-bind matrix,
+     * or inverse bind pose matrix.
+     */
+    C_STRUCT aiMatrix4x4 mOffsetMatrix;
+
+    /// Matrix that transforms the locale bone in bind pose.
+    C_STRUCT aiMatrix4x4 mLocalMatrix;
+
+#ifdef __cplusplus
+    ///	@brief The class constructor.
+    aiSkeletonBone() :
+            mParent(-1),
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+            mArmature(nullptr),
+            mNode(nullptr),
+#endif
+            mNumnWeights(0),
+            mMeshId(nullptr),
+            mWeights(nullptr),
+            mOffsetMatrix(),
+            mLocalMatrix() {
+        // empty
+    }
+
+    /// @brief The class constructor with its parent
+    /// @param  parent      The parent node index.
+    aiSkeletonBone(unsigned int parent) :
+            mParent(parent),
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+            mArmature(nullptr),
+            mNode(nullptr),
+#endif
+            mNumnWeights(0),
+            mMeshId(nullptr),
+            mWeights(nullptr),
+            mOffsetMatrix(),
+            mLocalMatrix() {
+        // empty
+    }
+    /// @brief The class destructor.
+    ~aiSkeletonBone() {
+        delete[] mWeights;
+        mWeights = nullptr;
+    }
+#endif // __cplusplus
+};
+/**
+ * @brief A skeleton represents the bone hierarchy of an animation.
+ *
+ * Skeleton animations can be described as a tree of bones:
+ *                  root
+ *                    |
+ *                  node1
+ *                  /   \
+ *               node3  node4
+ * If you want to calculate the transformation of node three you need to compute the
+ * transformation hierarchy for the transformation chain of node3:
+ * root->node1->node3
+ * Each node is represented as a skeleton instance.
+ */
+struct aiSkeleton {
+    /**
+     *  @brief The name of the skeleton instance.
+     */
+    C_STRUCT aiString mName;
+
+    /**
+     *  @brief  The number of bones in the skeleton.
+     */
+    unsigned int mNumBones;
+
+    /**
+     *  @brief The bone instance in the skeleton.
+     */
+    C_STRUCT aiSkeletonBone **mBones;
+
+#ifdef __cplusplus
+    /**
+     *  @brief The class constructor.
+     */
+    aiSkeleton() AI_NO_EXCEPT : mName(), mNumBones(0), mBones(nullptr) {
+        // empty
+    }
+
+    /**
+     *  @brief  The class destructor.
+     */
+    ~aiSkeleton() {
+        delete[] mBones;
+    }
+#endif // __cplusplus
+};
 #ifdef __cplusplus
 }
 #endif //! extern "C"
+
 #endif // AI_MESH_H_INC
+
diff --git a/D3D11Engine/include/assimp/metadata.h b/D3D11Engine/include/assimp/metadata.h
index 57fedfbf..c766d0ae 100644
--- a/D3D11Engine/include/assimp/metadata.h
+++ b/D3D11Engine/include/assimp/metadata.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -56,6 +56,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stdint.h>
 #endif
 
+#include <assimp/quaternion.h>
+
 // -------------------------------------------------------------------------------
 /**
   * Enum used to distinguish data types
@@ -70,7 +72,9 @@ typedef enum aiMetadataType {
     AI_AISTRING = 5,
     AI_AIVECTOR3D = 6,
     AI_AIMETADATA = 7,
-    AI_META_MAX = 8,
+    AI_INT64 = 8,
+    AI_UINT32 = 9,
+    AI_META_MAX = 10,
 
 #ifndef SWIG
     FORCE_32BIT = INT_MAX
@@ -133,6 +137,12 @@ inline aiMetadataType GetAiType(const aiVector3D &) {
 inline aiMetadataType GetAiType(const aiMetadata &) {
     return AI_AIMETADATA;
 }
+inline aiMetadataType GetAiType(int64_t) {
+    return AI_INT64;
+}
+inline aiMetadataType GetAiType(uint32_t) {
+    return AI_UINT32;
+}
 
 #endif // __cplusplus
 
@@ -215,6 +225,16 @@ struct aiMetadata {
                 rhs.Get<aiMetadata>(static_cast<unsigned int>(i), v);
                 mValues[i].mData = new aiMetadata(v);
             } break;
+            case AI_INT64: {
+                int64_t v;
+                ::memcpy(&v, rhs.mValues[i].mData, sizeof(int64_t));
+                mValues[i].mData = new int64_t(v);
+            } break;
+            case AI_UINT32: {
+                uint32_t v;
+                ::memcpy(&v, rhs.mValues[i].mData, sizeof(uint32_t));
+                mValues[i].mData = new uint32_t(v);
+            } break;
 #ifndef SWIG
             case FORCE_32BIT:
 #endif
@@ -267,6 +287,12 @@ struct aiMetadata {
                 case AI_AIMETADATA:
                     delete static_cast<aiMetadata *>(data);
                     break;
+                case AI_INT64:
+                    delete static_cast<int64_t *>(data);
+                    break;
+                case AI_UINT32:
+                    delete static_cast<uint32_t *>(data);
+                    break;
 #ifndef SWIG
                 case FORCE_32BIT:
 #endif
@@ -510,6 +536,16 @@ struct aiMetadata {
                     return false;
                 }
             } break;
+            case AI_INT64: {
+                if (*static_cast<int64_t *>(lhs.mValues[i].mData) != *static_cast<int64_t *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_UINT32: {
+                if (*static_cast<uint32_t *>(lhs.mValues[i].mData) != *static_cast<uint32_t *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
 #ifndef SWIG
             case FORCE_32BIT:
 #endif
diff --git a/D3D11Engine/include/assimp/pbrmaterial.h b/D3D11Engine/include/assimp/pbrmaterial.h
index b642a96e..3bdf151a 100644
--- a/D3D11Engine/include/assimp/pbrmaterial.h
+++ b/D3D11Engine/include/assimp/pbrmaterial.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -61,7 +61,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR AI_MATKEY_METALLIC_FACTOR
 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR AI_MATKEY_ROUGHNESS_FACTOR
 
-//#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS "$mat.gltf.pbrSpecularGlossiness", 0, 0
+#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS AI_MATKEY_GLOSSINESS_FACTOR
 #define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR AI_MATKEY_GLOSSINESS_FACTOR
 
 // Use AI_MATKEY_SHADING_MODEL == aiShadingMode_Unlit instead
diff --git a/D3D11Engine/include/assimp/postprocess.h b/D3D11Engine/include/assimp/postprocess.h
index 094fbf59..a905a8be 100644
--- a/D3D11Engine/include/assimp/postprocess.h
+++ b/D3D11Engine/include/assimp/postprocess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -94,6 +94,7 @@ enum aiPostProcessSteps
      * indexed geometry, this step is compulsory or you'll just waste rendering
      * time. <b>If this flag is not specified</b>, no vertices are referenced by
      * more than one face and <b>no index buffer is required</b> for rendering.
+     * Unless the importer (like ply) had to split vertices. Then you need one regardless.
      */
     aiProcess_JoinIdenticalVertices = 0x2,
 
diff --git a/D3D11Engine/include/assimp/qnan.h b/D3D11Engine/include/assimp/qnan.h
index 0999f5e7..c64cabaa 100644
--- a/D3D11Engine/include/assimp/qnan.h
+++ b/D3D11Engine/include/assimp/qnan.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
diff --git a/D3D11Engine/include/assimp/quaternion.h b/D3D11Engine/include/assimp/quaternion.h
index 6941fbbc..7ab3ad6f 100644
--- a/D3D11Engine/include/assimp/quaternion.h
+++ b/D3D11Engine/include/assimp/quaternion.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -36,7 +35,6 @@ 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.
-
 ----------------------------------------------------------------------
 */
 
@@ -55,21 +53,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/defs.h>
 
+// Forward declarations
 template <typename TReal> class aiVector3t;
 template <typename TReal> class aiMatrix3x3t;
 template <typename TReal> class aiMatrix4x4t;
 
 // ---------------------------------------------------------------------------
-/** Represents a quaternion in a 4D vector. */
+/**
+ *  @brief  This class represents a quaternion as a 4D vector.
+ */
 template <typename TReal>
-class aiQuaterniont
-{
+class aiQuaterniont {
 public:
     aiQuaterniont() AI_NO_EXCEPT : w(1.0), x(), y(), z() {}
     aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
         : w(pw), x(px), y(py), z(pz) {}
 
-    /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */
+    /**
+     *  @brief  Construct from rotation matrix. Result is undefined if the matrix is not orthonormal.
+     */
     explicit aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
 
     /** Construct from euler angles */
@@ -84,33 +86,38 @@ class aiQuaterniont
     /** Returns a matrix representation of the quaternion */
     aiMatrix3x3t<TReal> GetMatrix() const;
 
-public:
-
     bool operator== (const aiQuaterniont& o) const;
     bool operator!= (const aiQuaterniont& o) const;
 
     // transform vector by matrix
     aiQuaterniont& operator *= (const aiMatrix4x4t<TReal>& mat);
 
-    bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
-
-public:
+    bool Equal(const aiQuaterniont &o, TReal epsilon = ai_epsilon) const;
 
-    /** Normalize the quaternion */
+    /**
+     *  @brief  Will normalize the quaternion representation.
+     */
     aiQuaterniont& Normalize();
 
-    /** Compute quaternion conjugate */
-    aiQuaterniont& Conjugate ();
-
-    /** Rotate a point by this quaternion */
-    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in) const;
+    /**
+     *  @brief  Will compute the quaternion conjugate. The result will be stored in the instance.
+     */
+    aiQuaterniont& Conjugate();
 
-    /** Multiply two quaternions */
-    aiQuaterniont operator* (const aiQuaterniont& two) const;
+    /**
+     *  @brief  Rotate a point by this quaternion
+     */
+    aiVector3t<TReal> Rotate(const aiVector3t<TReal>& in) const;
 
-public:
+    /**
+     *  @brief Multiply two quaternions
+     *  @param  two   The other quaternion.
+     *  @return The result of the multiplication.
+     */
+    aiQuaterniont operator * (const aiQuaterniont& two) const;
 
-    /** Performs a spherical interpolation between two quaternions and writes the result into the third.
+    /**
+     * @brief Performs a spherical interpolation between two quaternions and writes the result into the third.
      * @param pOut Target object to received the interpolated rotation.
      * @param pStart Start rotation of the interpolation at factor == 0.
      * @param pEnd End rotation, factor == 1.
@@ -119,13 +126,11 @@ class aiQuaterniont
     static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart,
         const aiQuaterniont& pEnd, TReal pFactor);
 
-public:
-
     //! w,x,y,z components of the quaternion
     TReal w, x, y, z;
 } ;
 
-typedef aiQuaterniont<ai_real> aiQuaternion;
+using aiQuaternion = aiQuaterniont<ai_real>;
 
 #else
 
diff --git a/D3D11Engine/include/assimp/quaternion.inl b/D3D11Engine/include/assimp/quaternion.inl
index 3f8abc68..2cb24653 100644
--- a/D3D11Engine/include/assimp/quaternion.inl
+++ b/D3D11Engine/include/assimp/quaternion.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -237,7 +237,8 @@ inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuat
 
     // Calculate coefficients
     TReal sclp, sclq;
-    if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon
+
+    if ((static_cast<TReal>(1.0) - cosom) > ai_epsilon) // 0.0001 -> some epsillon
     {
         // Standard case (slerp)
         TReal omega, sinom;
diff --git a/D3D11Engine/include/assimp/scene.h b/D3D11Engine/include/assimp/scene.h
index 61c2d4c6..1b830a5b 100644
--- a/D3D11Engine/include/assimp/scene.h
+++ b/D3D11Engine/include/assimp/scene.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -79,8 +79,7 @@ extern "C" {
  * the imported scene does consist of only a single root node without children.
  */
 // -------------------------------------------------------------------------------
-struct ASSIMP_API aiNode
-{
+struct ASSIMP_API aiNode {
     /** The name of the node.
      *
      * The name might be empty (length of zero) but all nodes which
@@ -343,6 +342,16 @@ struct aiScene
      */
     C_STRUCT aiString mName;
 
+    /**
+     *
+     */
+    unsigned int mNumSkeletons;
+
+    /**
+     *
+     */
+    C_STRUCT aiSkeleton **mSkeletons;
+
 #ifdef __cplusplus
 
     //! Default constructor - set everything to 0/nullptr
@@ -383,6 +392,10 @@ struct aiScene
         return mAnimations != nullptr && mNumAnimations > 0;
     }
 
+    bool hasSkeletons() const {
+        return mSkeletons != nullptr && mNumSkeletons > 0;
+    }
+
     //! Returns a short filename from a full path
     static const char* GetShortFilename(const char* filename) {
         const char* lastSlash = strrchr(filename, '/');
@@ -420,7 +433,7 @@ struct aiScene
         for (unsigned int i = 0; i < mNumTextures; i++) {
             const char* shortTextureFilename = GetShortFilename(mTextures[i]->mFilename.C_Str());
             if (strcmp(shortTextureFilename, shortFilename) == 0) {
-                return std::make_pair(mTextures[i], i);
+                return std::make_pair(mTextures[i], static_cast<int>(i));
             }
         }
         return std::make_pair(nullptr, -1);
@@ -437,7 +450,7 @@ struct aiScene
 };
 
 #ifdef __cplusplus
-} 
+}
 #endif //! extern "C"
 
 #endif // AI_SCENE_H_INC
diff --git a/D3D11Engine/include/assimp/texture.h b/D3D11Engine/include/assimp/texture.h
index 7a9d38cc..576fa771 100644
--- a/D3D11Engine/include/assimp/texture.h
+++ b/D3D11Engine/include/assimp/texture.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -92,22 +92,19 @@ struct aiTexel {
 
 #ifdef __cplusplus
     //! Comparison operator
-    bool operator== (const aiTexel& other) const
-    {
+    bool operator== (const aiTexel& other) const {
         return b == other.b && r == other.r &&
                g == other.g && a == other.a;
     }
 
     //! Inverse comparison operator
-    bool operator!= (const aiTexel& other) const
-    {
+    bool operator!= (const aiTexel& other) const {
         return b != other.b || r != other.r ||
                g != other.g || a != other.a;
     }
 
     //! Conversion to a floating-point 4d color
-    operator aiColor4D() const
-    {
+    operator aiColor4D() const {
         return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
     }
 #endif // __cplusplus
@@ -202,11 +199,11 @@ struct aiTexture {
     }
 
     // Construction
-    aiTexture() AI_NO_EXCEPT
-    : mWidth(0)
-    , mHeight(0)
-    , pcData(nullptr)
-    , mFilename() {
+    aiTexture() AI_NO_EXCEPT :
+            mWidth(0),
+            mHeight(0),
+            pcData(nullptr),
+            mFilename() {
         memset(achFormatHint, 0, sizeof(achFormatHint));
     }
 
diff --git a/D3D11Engine/include/assimp/types.h b/D3D11Engine/include/assimp/types.h
index 47af917a..605dc590 100644
--- a/D3D11Engine/include/assimp/types.h
+++ b/D3D11Engine/include/assimp/types.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -73,6 +73,12 @@ typedef uint32_t ai_uint32;
 
 #ifdef __cplusplus
 
+#ifdef ASSIMP_USE_HUNTER
+#   include <utf8.h>
+#else
+#   include "../contrib/utf8cpp/source/utf8.h"
+#endif
+
 #include <cstring>
 #include <new> // for std::nothrow_t
 #include <string> // for aiString::Set(const std::string&)
diff --git a/D3D11Engine/include/assimp/vector2.h b/D3D11Engine/include/assimp/vector2.h
index 34adf894..f06e9441 100644
--- a/D3D11Engine/include/assimp/vector2.h
+++ b/D3D11Engine/include/assimp/vector2.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -87,7 +85,7 @@ class aiVector2t {
     bool operator== (const aiVector2t& other) const;
     bool operator!= (const aiVector2t& other) const;
 
-    bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
+    bool Equal(const aiVector2t &other, TReal epsilon = ai_epsilon) const;
 
     aiVector2t& operator= (TReal f);
     const aiVector2t SymMul(const aiVector2t& o);
diff --git a/D3D11Engine/include/assimp/vector2.inl b/D3D11Engine/include/assimp/vector2.inl
index b51dd0ec..245eb319 100644
--- a/D3D11Engine/include/assimp/vector2.inl
+++ b/D3D11Engine/include/assimp/vector2.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
diff --git a/D3D11Engine/include/assimp/vector3.h b/D3D11Engine/include/assimp/vector3.h
index e3ad0b68..5d0962b6 100644
--- a/D3D11Engine/include/assimp/vector3.h
+++ b/D3D11Engine/include/assimp/vector3.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -70,17 +70,17 @@ class aiVector3t {
 public:
     /// @brief  The default class constructor.
     aiVector3t() AI_NO_EXCEPT : x(), y(), z() {}
-    
+
     /// @brief  The class constructor with the components.
     /// @param  _x  The x-component for the vector.
     /// @param  _y  The y-component for the vector.
     /// @param  _z  The z-component for the vector.
     aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
-    
+
     /// @brief  The class constructor with a default value.
     /// @param  _xyz  The value for x, y and z.
     explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {}
-    
+
     /// @brief  The copy constructor.
     /// @param  o The instance to copy from.
     aiVector3t( const aiVector3t& o ) = default;
@@ -113,8 +113,8 @@ class aiVector3t {
     bool operator!= (const aiVector3t& other) const;
     bool operator < (const aiVector3t& other) const;
 
-    /// @brief  
-    bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
+    /// @brief
+    bool Equal(const aiVector3t &other, TReal epsilon = ai_epsilon) const;
 
     template <typename TOther>
     operator aiVector3t<TOther> () const;
diff --git a/D3D11Engine/include/assimp/vector3.inl b/D3D11Engine/include/assimp/vector3.inl
index 0076d2a8..28ca2be0 100644
--- a/D3D11Engine/include/assimp/vector3.inl
+++ b/D3D11Engine/include/assimp/vector3.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -54,8 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ------------------------------------------------------------------------------------------------
 /** Transformation of a vector by a 3x3 matrix */
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
     aiVector3t<TReal> res;
     res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
     res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
@@ -66,8 +65,7 @@ aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector
 // ------------------------------------------------------------------------------------------------
 /** Transformation of a vector by a 4x4 matrix */
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
     aiVector3t<TReal> res;
     res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
     res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
@@ -82,36 +80,35 @@ aiVector3t<TReal>::operator aiVector3t<TOther> () const {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
+AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
     x = pX;
     y = pY;
     z = pZ;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiVector3t<TReal>::SquareLength() const {
+AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const {
     return x*x + y*y + z*z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiVector3t<TReal>::Length() const {
+AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const {
     return std::sqrt( SquareLength());
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
+ aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
+    const TReal l = Length();
+    if (l == 0) {
+        return *this;
+    }
     *this /= Length();
 
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
+AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
     TReal len = Length();
     if ( len > static_cast< TReal >( 0 ) ) {
         *this /= len;
@@ -120,8 +117,7 @@ aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
     x += o.x;
     y += o.y;
     z += o.z;
@@ -130,8 +126,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
     x -= o.x;
     y -= o.y;
     z -= o.z;
@@ -140,8 +135,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
     x *= f;
     y *= f;
     z *= f;
@@ -150,8 +144,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
     if ( f == static_cast<TReal>(0.0)) {
         return *this;
     }
@@ -164,20 +157,17 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
+AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
     return (*this =  mat * (*this));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
+AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
     return (*this = mat * (*this));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiVector3t<TReal>::operator[](unsigned int i) const {
+AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const {
     switch (i) {
         case 0:
             return x;
@@ -192,9 +182,7 @@ TReal aiVector3t<TReal>::operator[](unsigned int i) const {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal& aiVector3t<TReal>::operator[](unsigned int i) {
-//    return *(&x + i);
+AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) {
     switch (i) {
         case 0:
             return x;
@@ -209,20 +197,17 @@ TReal& aiVector3t<TReal>::operator[](unsigned int i) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
     return x == other.x && y == other.y && z == other.z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
     return x != other.x || y != other.y || z != other.z;
 }
 // ---------------------------------------------------------------------------
 template<typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
     return
         std::abs(x - other.x) <= epsilon &&
         std::abs(y - other.y) <= epsilon &&
@@ -230,77 +215,66 @@ bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) con
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
     return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
+AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
     return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
 }
 // ------------------------------------------------------------------------------------------------
 // symmetric addition
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // symmetric subtraction
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // scalar product
 template <typename TReal>
-AI_FORCE_INLINE
-TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
 }
 // ------------------------------------------------------------------------------------------------
 // scalar multiplication
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
     return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
 }
 // ------------------------------------------------------------------------------------------------
 // and the other way around
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
     return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
 }
 // ------------------------------------------------------------------------------------------------
 // scalar division
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
+AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
     return v * (1/f);
 }
 // ------------------------------------------------------------------------------------------------
 // vector division
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // cross product
 template<typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
 }
 // ------------------------------------------------------------------------------------------------
 // vector negation
 template<typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
+AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
     return aiVector3t<TReal>( -v.x, -v.y, -v.z);
 }
 
diff --git a/D3D11Engine/include/assimp/version.h b/D3D11Engine/include/assimp/version.h
index 09a35dbb..b83110a0 100644
--- a/D3D11Engine/include/assimp/version.h
+++ b/D3D11Engine/include/assimp/version.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2021, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.