Merge branch 'master' into master

code/3DS/3DSConverter.cpp

@@ -5,8 +5,6 @@ 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,
@@ -43,7 +41,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the 3ds importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers

code/3DS/3DSHelper.h

@@ -322,7 +322,7 @@ struct Face : public FaceWithSmoothingGroup {
 };
 
 #ifdef _WIN32
-#    pragma warning(disable : 4315)
+#pragma warning(disable : 4315)
 #endif
 
 // ---------------------------------------------------------------------------
@@ -441,12 +441,33 @@ struct Material {
         // empty
     }
 
-    Material(const Material &other) = default;
+    Material(const Material &other) :
-    Material &operator=(const Material &other) = default;
+            mName(other.mName),
+            mDiffuse(other.mDiffuse),
+            mSpecularExponent(other.mSpecularExponent),
+            mShininessStrength(other.mShininessStrength),
+            mSpecular(other.mSpecular),
+            mAmbient(other.mAmbient),
+            mShading(other.mShading),
+            mTransparency(other.mTransparency),
+            sTexDiffuse(other.sTexDiffuse),
+            sTexOpacity(other.sTexOpacity),
+            sTexSpecular(other.sTexSpecular),
+            sTexReflective(other.sTexReflective),
+            sTexBump(other.sTexBump),
+            sTexEmissive(other.sTexEmissive),
+            sTexShininess(other.sTexShininess),
+            mBumpHeight(other.mBumpHeight),
+            mEmissive(other.mEmissive),
+            sTexAmbient(other.sTexAmbient),
+            mTwoSided(other.mTwoSided) {
+        // empty
+
+    }
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other) AI_NO_EXCEPT
+    Material(Material &&other) AI_NO_EXCEPT :
-            : mName(std::move(other.mName)),
+            mName(std::move(other.mName)),
             mDiffuse(std::move(other.mDiffuse)),
             mSpecularExponent(std::move(other.mSpecularExponent)),
             mShininessStrength(std::move(other.mShininessStrength)),
@@ -465,6 +486,7 @@ struct Material {
             mEmissive(std::move(other.mEmissive)),
             sTexAmbient(std::move(other.sTexAmbient)),
             mTwoSided(std::move(other.mTwoSided)) {
+        // empty
     }
 
     Material &operator=(Material &&other) AI_NO_EXCEPT {

code/3DS/3DSLoader.cpp

@@ -5,8 +5,6 @@ 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,
@@ -72,7 +70,6 @@ static const aiImporterDesc desc = {
 	"3ds prj"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Begins a new parsing block
 // - Reads the current chunk and validates it
@@ -141,15 +138,13 @@ bool Discreet3DSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandle
 
 // ------------------------------------------------------------------------------------------------
 // Loader registry entry
-const aiImporterDesc* Discreet3DSImporter::GetInfo () const
+const aiImporterDesc* Discreet3DSImporter::GetInfo () const {
-{
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/)
+void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/) {
-{
     // nothing to be done for the moment
 }
 
@@ -200,7 +195,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
         ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
     }
 
-    // Replace all occurences of the default material with a
+    // Replace all occurrences of the default material with a
     // valid material. Generate it if no material containing
     // DEFAULT in its name has been found in the file
     ReplaceDefaultMaterial();
@@ -227,8 +222,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
 
 // ------------------------------------------------------------------------------------------------
 // Applies a master-scaling factor to the imported scene
-void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene)
+void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene) {
-{
     // There are some 3DS files with a zero scaling factor
     if (!mMasterScale)mMasterScale = 1.0f;
     else mMasterScale = 1.0f / mMasterScale;
@@ -1084,7 +1078,7 @@ void Discreet3DSImporter::ParseMeshChunk()
         mMesh.mFaceMaterials.resize(mMesh.mFaces.size(),0xcdcdcdcd);
 
         // Larger 3DS files could have multiple FACE chunks here
-        chunkSize = stream->GetRemainingSizeToLimit();
+        chunkSize = (int)stream->GetRemainingSizeToLimit();
         if ( chunkSize > (int) sizeof(Discreet3DS::Chunk ) )
             ParseFaceChunk();
         }

code/3DS/3DSLoader.h

@@ -65,15 +65,11 @@ using namespace D3DS;
 // ---------------------------------------------------------------------------------
 /** Importer class for 3D Studio r3 and r4 3DS files
  */
-class Discreet3DSImporter : public BaseImporter
+class Discreet3DSImporter : public BaseImporter {
-{
 public:
-
     Discreet3DSImporter();
     ~Discreet3DSImporter();
 
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.

code/Assjson/cencode.c

@@ -9,6 +9,9 @@ For details, see http://sourceforge.net/projects/libb64
 
 const int CHARS_PER_LINE = 72;
 
+#pragma warning(push)
+#pragma warning(disable : 4244)
+
 void base64_init_encodestate(base64_encodestate* state_in)
 {
 	state_in->step = step_A;
@@ -107,3 +110,4 @@ int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 	return (int)(codechar - code_out);
 }
 
+#pragma warning(pop)

code/Blender/BlenderLoader.cpp

@@ -206,7 +206,7 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
         inflateInit2(&zstream, 16+MAX_WBITS);
 
         zstream.next_in   = reinterpret_cast<Bytef*>( reader->GetPtr() );
-        zstream.avail_in  = reader->GetRemainingSize();
+        zstream.avail_in  = (uInt) reader->GetRemainingSize();
 
         size_t total = 0l;
 

code/CSM/CSMLoader.cpp

@@ -178,7 +178,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                         *ot++ = *buffer++;
 
                     *ot = '\0';
-                    nda->mNodeName.length = (ai_uint32)(ot-nda->mNodeName.data);
+                    nda->mNodeName.length = static_cast<ai_uint32>(ot-nda->mNodeName.data);
                 }
 
                 anim->mNumChannels = static_cast<unsigned int>(anims_temp.size());

code/Irr/IRRLoader.cpp

@@ -1483,6 +1483,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
      */
 
     delete root;
+	delete reader;
 }
 
 #endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER

code/M3D/M3DExporter.cpp

@@ -292,8 +292,8 @@ void ExportSceneM3D(
 // Prototyped and registered in Exporter.cpp
 void ExportSceneM3DA(
         const char *,
-        IOSystem*,
+        IOSystem *,
-        const aiScene*,
+        const aiScene *,
         const ExportProperties *
 
 ) {
@@ -312,7 +312,9 @@ void ExportSceneM3DA(
 M3DExporter::M3DExporter(const aiScene *pScene, const ExportProperties *pProperties) :
         mScene(pScene),
         mProperties(pProperties),
-        outfile() {}
+        outfile() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 void M3DExporter::doExport(
@@ -352,6 +354,9 @@ void M3DExporter::doExport(
     // explicitly release file pointer,
     // so we don't have to rely on class destruction.
     outfile.reset();
+
+    M3D_FREE(m3d->name);
+    m3d->name = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------

code/M3D/M3DWrapper.cpp

@@ -50,15 +50,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef ASSIMP_USE_M3D_READFILECB
 
-# if (__cplusplus >= 201103L) || !defined(_MSC_VER) || (_MSC_VER >= 1900) // C++11 and MSVC 2015 onwards
+#if (__cplusplus >= 201103L) || !defined(_MSC_VER) || (_MSC_VER >= 1900) // C++11 and MSVC 2015 onwards
-#  define threadlocal thread_local
+#define threadlocal thread_local
-# else
+#else
-#  if defined(_MSC_VER) && (_MSC_VER >= 1800) // there's an alternative for MSVC 2013
+#if defined(_MSC_VER) && (_MSC_VER >= 1800) // there's an alternative for MSVC 2013
-#   define threadlocal __declspec(thread)
+#define threadlocal __declspec(thread)
-#  else
+#else
-#   define threadlocal
+#define threadlocal
-#  endif
+#endif
-# endif
+#endif
 
 extern "C" {
 
@@ -121,8 +121,9 @@ M3DWrapper::~M3DWrapper() {
 
 void M3DWrapper::reset() {
     ClearSave();
-	if (m3d_)
+    if (m3d_) {
         m3d_free(m3d_);
+    }
     m3d_ = nullptr;
 }
 

code/M3D/m3d.h

@@ -5440,13 +5440,13 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         out += 2;
                         break;
                     case 4:
-                        *((float *)out) = vrtx[i].data.x;
+                        memcpy(out, &vrtx[i].data.x, sizeof(float));
                         out += 4;
-                        *((float *)out) = vrtx[i].data.y;
+                        memcpy(out, &vrtx[i].data.y, sizeof(float));
                         out += 4;
-                        *((float *)out) = vrtx[i].data.z;
+                        memcpy(out, &vrtx[i].data.z, sizeof(float));
                         out += 4;
-                        *((float *)out) = vrtx[i].data.w;
+                        memcpy(out, &vrtx[i].data.w, sizeof(float));
                         out += 4;
                         break;
                     case 8:
@@ -5474,9 +5474,11 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                 }
                 out = _m3d_addidx(out, sk_s, vrtx[i].data.skinid);
             }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            memcpy(length, &v, sizeof(uint32_t));
+            //*length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
             out = NULL;
-            len += *length;
+            len += v;
         }
         /* bones chunk */
         if (model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
@@ -5660,8 +5662,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.normal[j]]);
                 }
             }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-            len += *length;
+            memcpy(length, &v, sizeof(uint32_t));
+            len += v;
             out = NULL;
         }
         /* mathematical shapes face */
@@ -5721,8 +5724,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         }
                     }
                 }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-                len += *length;
+                memcpy( length, &v, sizeof(uint32_t));
+                len += v;
                 out = NULL;
             }
         }
@@ -5765,8 +5769,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].text));
             }
             if (length) {
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-                len += *length;
+                memcpy( length, &v, sizeof(uint32_t));                
+                len += v;
             }
             out = NULL;
             sn = sl = NULL;
@@ -5796,8 +5801,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].ori]);
                     }
                 }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-                len += *length;
+                memcpy( length, &v, sizeof(uint32_t));                
+                len += v;
                 out = NULL;
             }
         }

code/Material/MaterialSystem.cpp

@@ -503,7 +503,7 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
     pcNew->mData = new char[pSizeInBytes];
     memcpy (pcNew->mData,pInput,pSizeInBytes);
 
-    pcNew->mKey.length = (ai_uint32)::strlen(pKey);
+    pcNew->mKey.length = static_cast<ai_uint32>( ::strlen(pKey) );
     ai_assert ( MAXLEN > pcNew->mKey.length);
     strcpy( pcNew->mKey.data, pKey );
 

code/Q3BSP/Q3BSPFileImporter.cpp

@@ -617,7 +617,7 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model
             // We'll leave it up to the user to figure out which extension the file has.
             aiString name;
             strncpy( name.data, pTexture->strName, sizeof name.data );
-            name.length = (ai_uint32)strlen( name.data );
+            name.length = static_cast<ai_uint32>(strlen( name.data ));
             pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
         }
     }

code/SMD/SMDLoader.cpp

@@ -616,7 +616,7 @@ void SMDImporter::CreateOutputMaterials() {
         if (aszTextures[iMat].length())
         {
             ::strncpy(szName.data, aszTextures[iMat].c_str(),MAXLEN-1);
-            szName.length = (ai_uint32)aszTextures[iMat].length();
+            szName.length = static_cast<ai_uint32>( aszTextures[iMat].length() );
             pcMat->AddProperty(&szName,AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
     }

code/Terragen/TerragenLoader.cpp

@@ -5,8 +5,6 @@ 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,
@@ -43,17 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the Terragen importer class */
 
-
-
 #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
 
 #include "TerragenLoader.h"
 #include <assimp/StreamReader.h>
-#include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
-#include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 
 using namespace Assimp;
 
@@ -72,78 +68,72 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-TerragenImporter::TerragenImporter()
+TerragenImporter::TerragenImporter() :
-: configComputeUVs (false)
+        configComputeUVs(false) {}
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-TerragenImporter::~TerragenImporter()
+TerragenImporter::~TerragenImporter() {}
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool TerragenImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
-{
     // check file extension
     std::string extension = GetExtension(pFile);
 
-    if( extension == "ter")
+    if (extension == "ter")
         return true;
 
-    if(  !extension.length() || checkSig)   {
+    if (!extension.length() || checkSig) {
         /*  If CanRead() is called in order to check whether we
          *  support a specific file extension in general pIOHandler
          *  might be NULL and it's our duty to return true here.
          */
-        if (!pIOHandler)return true;
+        if (!pIOHandler) return true;
-        const char* tokens[] = {"terragen"};
+        const char *tokens[] = { "terragen" };
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
     }
     return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* TerragenImporter::GetInfo () const
+const aiImporterDesc *TerragenImporter::GetInfo() const {
-{
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import properties
-void TerragenImporter::SetupProperties(const Importer* pImp)
+void TerragenImporter::SetupProperties(const Importer *pImp) {
-{
     // AI_CONFIG_IMPORT_TER_MAKE_UVS
-    configComputeUVs = ( 0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS,0) );
+    configComputeUVs = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void TerragenImporter::InternReadFile( const std::string& pFile,
+void TerragenImporter::InternReadFile(const std::string &pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
+        aiScene *pScene, IOSystem *pIOHandler) {
-{
+    IOStream *file = pIOHandler->Open(pFile, "rb");
-    IOStream* file = pIOHandler->Open( pFile, "rb");
 
     // Check whether we can read from the file
-    if( file == NULL)
+    if (file == NULL)
-        throw DeadlyImportError( "Failed to open TERRAGEN TERRAIN file " + pFile + ".");
+        throw DeadlyImportError("Failed to open TERRAGEN TERRAIN file " + pFile + ".");
 
     // Construct a stream reader to read all data in the correct endianness
     StreamReaderLE reader(file);
-    if(reader.GetRemainingSize() < 16)
+    if (reader.GetRemainingSize() < 16)
-        throw DeadlyImportError( "TER: file is too small" );
+        throw DeadlyImportError("TER: file is too small");
 
     // Check for the existence of the two magic strings 'TERRAGEN' and 'TERRAIN '
-    if (::strncmp((const char*)reader.GetPtr(),AI_TERR_BASE_STRING,8))
+    if (::strncmp((const char *)reader.GetPtr(), AI_TERR_BASE_STRING, 8))
-        throw DeadlyImportError( "TER: Magic string \'TERRAGEN\' not found" );
+        throw DeadlyImportError("TER: Magic string \'TERRAGEN\' not found");
 
-    if (::strncmp((const char*)reader.GetPtr()+8,AI_TERR_TERRAIN_STRING,8))
+    if (::strncmp((const char *)reader.GetPtr() + 8, AI_TERR_TERRAIN_STRING, 8))
-        throw DeadlyImportError( "TER: Magic string \'TERRAIN\' not found" );
+        throw DeadlyImportError("TER: Magic string \'TERRAIN\' not found");
 
-    unsigned int x = 0,y = 0,mode = 0;
+    unsigned int x = 0, y = 0, mode = 0;
 
-    aiNode* root = pScene->mRootNode = new aiNode();
+    aiNode *root = pScene->mRootNode = new aiNode();
     root->mName.Set("<TERRAGEN.TERRAIN>");
 
     // Default scaling is 30
@@ -151,104 +141,98 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
 
     // Now read all chunks until we're finished or an EOF marker is encountered
     reader.IncPtr(16);
-    while (reader.GetRemainingSize() >= 4)
+    while (reader.GetRemainingSize() >= 4) {
-    {
+        const char *head = (const char *)reader.GetPtr();
-        const char* head = (const char*)reader.GetPtr();
         reader.IncPtr(4);
 
         // EOF, break in every case
-        if (!::strncmp(head,AI_TERR_EOF_STRING,4))
+        if (!::strncmp(head, AI_TERR_EOF_STRING, 4))
             break;
 
         // Number of x-data points
-        if (!::strncmp(head,AI_TERR_CHUNK_XPTS,4))
+        if (!::strncmp(head, AI_TERR_CHUNK_XPTS, 4)) {
-        {
             x = (uint16_t)reader.GetI2();
         }
         // Number of y-data points
-        else if (!::strncmp(head,AI_TERR_CHUNK_YPTS,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_YPTS, 4)) {
-        {
             y = (uint16_t)reader.GetI2();
         }
         // Squared terrains width-1.
-        else if (!::strncmp(head,AI_TERR_CHUNK_SIZE,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_SIZE, 4)) {
-        {
+            x = y = (uint16_t)reader.GetI2() + 1;
-            x = y = (uint16_t)reader.GetI2()+1;
         }
         // terrain scaling
-        else if (!::strncmp(head,AI_TERR_CHUNK_SCAL,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_SCAL, 4)) {
-        {
             root->mTransformation.a1 = reader.GetF4();
             root->mTransformation.b2 = reader.GetF4();
             root->mTransformation.c3 = reader.GetF4();
         }
         // mapping == 1: earth radius
-        else if (!::strncmp(head,AI_TERR_CHUNK_CRAD,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_CRAD, 4)) {
-        {
             reader.GetF4();
         }
         // mapping mode
-        else if (!::strncmp(head,AI_TERR_CHUNK_CRVM,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_CRVM, 4)) {
-        {
             mode = reader.GetI1();
             if (0 != mode)
                 ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned");
         }
         // actual terrain data
-        else if (!::strncmp(head,AI_TERR_CHUNK_ALTW,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_ALTW, 4)) {
-        {
             float hscale = (float)reader.GetI2() / 65536;
             float bheight = (float)reader.GetI2();
 
-            if (!hscale)hscale = 1;
+            if (!hscale) hscale = 1;
 
             // Ensure we have enough data
-            if (reader.GetRemainingSize() < x*y*2)
+            if (reader.GetRemainingSize() < x * y * 2)
                 throw DeadlyImportError("TER: ALTW chunk is too small");
 
             if (x <= 1 || y <= 1)
                 throw DeadlyImportError("TER: Invalid terrain size");
 
             // Allocate the output mesh
-            pScene->mMeshes = new aiMesh*[pScene->mNumMeshes = 1];
+            pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = 1];
-            aiMesh* m = pScene->mMeshes[0] = new aiMesh();
+            aiMesh *m = pScene->mMeshes[0] = new aiMesh();
 
             // We return quads
-            aiFace* f = m->mFaces = new aiFace[m->mNumFaces = (x-1)*(y-1)];
+            aiFace *f = m->mFaces = new aiFace[m->mNumFaces = (x - 1) * (y - 1)];
-            aiVector3D* pv = m->mVertices = new aiVector3D[m->mNumVertices = m->mNumFaces*4];
+            aiVector3D *pv = m->mVertices = new aiVector3D[m->mNumVertices = m->mNumFaces * 4];
 
-            aiVector3D *uv( NULL );
+            aiVector3D *uv(NULL);
-            float step_y( 0.0f ), step_x( 0.0f );
+            float step_y(0.0f), step_x(0.0f);
             if (configComputeUVs) {
                 uv = m->mTextureCoords[0] = new aiVector3D[m->mNumVertices];
-                step_y = 1.f/y;
+                step_y = 1.f / y;
-                step_x = 1.f/x;
+                step_x = 1.f / x;
             }
-            const int16_t* data = (const int16_t*)reader.GetPtr();
+            const int16_t *data = (const int16_t *)reader.GetPtr();
 
-            for (unsigned int yy = 0, t = 0; yy < y-1;++yy) {
+            for (unsigned int yy = 0, t = 0; yy < y - 1; ++yy) {
-                for (unsigned int xx = 0; xx < x-1;++xx,++f)    {
+                for (unsigned int xx = 0; xx < x - 1; ++xx, ++f) {
 
                     // make verts
                     const float fy = (float)yy, fx = (float)xx;
-                    unsigned tmp,tmp2;
+                    unsigned tmp, tmp2;
-                    *pv++ = aiVector3D(fx,fy,    (float)data[(tmp2=x*yy)    + xx] * hscale + bheight);
+                    *pv++ = aiVector3D(fx, fy, (float)data[(tmp2 = x * yy) + xx] * hscale + bheight);
-                    *pv++ = aiVector3D(fx,fy+1,  (float)data[(tmp=x*(yy+1)) + xx] * hscale + bheight);
+                    *pv++ = aiVector3D(fx, fy + 1, (float)data[(tmp = x * (yy + 1)) + xx] * hscale + bheight);
-                    *pv++ = aiVector3D(fx+1,fy+1,(float)data[tmp  + xx+1]         * hscale + bheight);
+                    *pv++ = aiVector3D(fx + 1, fy + 1, (float)data[tmp + xx + 1] * hscale + bheight);
-                    *pv++ = aiVector3D(fx+1,fy,  (float)data[tmp2 + xx+1]         * hscale + bheight);
+                    *pv++ = aiVector3D(fx + 1, fy, (float)data[tmp2 + xx + 1] * hscale + bheight);
 
                     // also make texture coordinates, if necessary
                     if (configComputeUVs) {
-                        *uv++ = aiVector3D( step_x*xx,     step_y*yy,     0.f );
+                        *uv++ = aiVector3D(step_x * xx, step_y * yy, 0.f);
-                        *uv++ = aiVector3D( step_x*xx,     step_y*(yy+1), 0.f );
+                        *uv++ = aiVector3D(step_x * xx, step_y * (yy + 1), 0.f);
-                        *uv++ = aiVector3D( step_x*(xx+1), step_y*(yy+1), 0.f );
+                        *uv++ = aiVector3D(step_x * (xx + 1), step_y * (yy + 1), 0.f);
-                        *uv++ = aiVector3D( step_x*(xx+1), step_y*yy,     0.f );
+                        *uv++ = aiVector3D(step_x * (xx + 1), step_y * yy, 0.f);
                     }
 
                     // make indices
                     f->mIndices = new unsigned int[f->mNumIndices = 4];
-                    for (unsigned int i = 0; i < 4;++i)
+                    for (unsigned int i = 0; i < 4; ++i) {
-                        f->mIndices[i] = t++;
+                        f->mIndices[i] = t;
+                        t++;
+                    }
                 }
             }
 

code/Terragen/TerragenLoader.h

@@ -4,7 +4,6 @@ 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,
@@ -69,33 +68,28 @@ namespace Assimp    {
  *  The loader is basing on the information found here:
  *  http://www.planetside.co.uk/terragen/dev/tgterrain.html#chunks
 */
-class TerragenImporter : public BaseImporter
+class TerragenImporter : public BaseImporter {
-{
 public:
     TerragenImporter();
     ~TerragenImporter();
 
-
 public:
-
     // -------------------------------------------------------------------
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
             bool checkSig) const;
 
 protected:
+    // -------------------------------------------------------------------
+    const aiImporterDesc *GetInfo() const;
 
     // -------------------------------------------------------------------
-    const aiImporterDesc* GetInfo () const;
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler);
 
     // -------------------------------------------------------------------
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
+    void SetupProperties(const Importer *pImp);
-        IOSystem* pIOHandler);
-
-    // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
 
 private:
-
     bool configComputeUVs;
 
 }; //! class TerragenImporter

code/Unreal/UnrealLoader.cpp

@@ -5,8 +5,6 @@ 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,
@@ -48,26 +46,112 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    http://local.wasp.uwa.edu.au/~pbourke/dataformats/unreal/
  */
 
-
-
 #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
 
 #include "Unreal/UnrealLoader.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
-#include <assimp/StreamReader.h>
 #include <assimp/ParsingUtils.h>
+#include <assimp/StreamReader.h>
 #include <assimp/fast_atof.h>
-#include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
-#include <assimp/importerdesc.h>
 
+#include <stdint.h>
 #include <memory>
 
 using namespace Assimp;
 
+namespace Unreal {
+
+/*
+    0 = Normal one-sided
+    1 = Normal two-sided
+    2 = Translucent two-sided
+    3 = Masked two-sided
+    4 = Modulation blended two-sided
+    8 = Placeholder triangle for weapon positioning (invisible)
+    */
+enum MeshFlags {
+    MF_NORMAL_OS = 0,
+    MF_NORMAL_TS = 1,
+    MF_NORMAL_TRANS_TS = 2,
+    MF_NORMAL_MASKED_TS = 3,
+    MF_NORMAL_MOD_TS = 4,
+    MF_WEAPON_PLACEHOLDER = 8
+};
+
+// a single triangle
+struct Triangle {
+    uint16_t mVertex[3]; // Vertex indices
+    char mType; // James' Mesh Type
+    char mColor; // Color for flat and Gourand Shaded
+    unsigned char mTex[3][2]; // Texture UV coordinates
+    unsigned char mTextureNum; // Source texture offset
+    char mFlags; // Unreal Mesh Flags (unused)
+    unsigned int matIndex;
+};
+
+// temporary representation for a material
+struct TempMat {
+    TempMat() :
+            type(MF_NORMAL_OS), tex(), numFaces(0) {}
+
+    explicit TempMat(const Triangle &in) :
+            type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {}
+
+    // type of mesh
+    Unreal::MeshFlags type;
+
+    // index of texture
+    unsigned int tex;
+
+    // number of faces using us
+    unsigned int numFaces;
+
+    // for std::find
+    bool operator==(const TempMat &o) {
+        return (tex == o.tex && type == o.type);
+    }
+};
+
+struct Vertex {
+    int32_t X : 11;
+    int32_t Y : 11;
+    int32_t Z : 10;
+};
+
+// UNREAL vertex compression
+inline void CompressVertex(const aiVector3D &v, uint32_t &out) {
+    union {
+        Vertex n;
+        int32_t t;
+    };
+    t = 0;
+    n.X = (int32_t)v.x;
+    n.Y = (int32_t)v.y;
+    n.Z = (int32_t)v.z;
+    ::memcpy(&out, &t, sizeof(int32_t));
+}
+
+// UNREAL vertex decompression
+inline void DecompressVertex(aiVector3D &v, int32_t in) {
+    union {
+        Vertex n;
+        int32_t i;
+    };
+    i = in;
+
+    v.x = (float)n.X;
+    v.y = (float)n.Y;
+    v.z = (float)n.Z;
+}
+
+} // end namespace Unreal
+
 static const aiImporterDesc desc = {
     "Unreal Mesh Importer",
     "",
@@ -81,60 +165,52 @@ static const aiImporterDesc desc = {
     "3d uc"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-UnrealImporter::UnrealImporter()
+UnrealImporter::UnrealImporter() :
-:   configFrameID   (0)
+        mConfigFrameID(0), mConfigHandleFlags(true) {}
-,   configHandleFlags (true)
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-UnrealImporter::~UnrealImporter()
+UnrealImporter::~UnrealImporter() {}
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool UnrealImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
+bool UnrealImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
-{
+    return SimpleExtensionCheck(pFile, "3d", "uc");
-    return  SimpleExtensionCheck(pFile,"3d","uc");
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* UnrealImporter::GetInfo () const
+const aiImporterDesc *UnrealImporter::GetInfo() const {
-{
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void UnrealImporter::SetupProperties(const Importer* pImp)
+void UnrealImporter::SetupProperties(const Importer *pImp) {
-{
     // The
     // AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the
     // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME,-1);
+    mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME, -1);
-    if(static_cast<unsigned int>(-1) == configFrameID)  {
+    if (static_cast<unsigned int>(-1) == mConfigFrameID) {
-        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+        mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
     }
 
     // AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true
-    configHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS,1));
+    mConfigHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, 1));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void UnrealImporter::InternReadFile( const std::string& pFile,
+void UnrealImporter::InternReadFile(const std::string &pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
+        aiScene *pScene, IOSystem *pIOHandler) {
-{
     // For any of the 3 files being passed get the three correct paths
     // First of all, determine file extension
     std::string::size_type pos = pFile.find_last_of('.');
     std::string extension = GetExtension(pFile);
 
-    std::string d_path,a_path,uc_path;
+    std::string d_path, a_path, uc_path;
     if (extension == "3d") {
         // jjjj_d.3d
         // jjjj_a.3d
@@ -142,18 +218,17 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         if (std::string::npos == pos) {
             throw DeadlyImportError("UNREAL: Unexpected naming scheme");
         }
-        extension = pFile.substr(0,pos);
+        extension = pFile.substr(0, pos);
-    }
+    } else {
-    else {
+        extension = pFile.substr(0, pos);
-        extension = pFile.substr(0,pos);
     }
 
     // build proper paths
-    d_path  = extension+"_d.3d";
+    d_path = extension + "_d.3d";
-    a_path  = extension+"_a.3d";
+    a_path = extension + "_a.3d";
-    uc_path = extension+".uc";
+    uc_path = extension + ".uc";
 
-    ASSIMP_LOG_DEBUG_F( "UNREAL: data file is ", d_path);
+    ASSIMP_LOG_DEBUG_F("UNREAL: data file is ", d_path);
     ASSIMP_LOG_DEBUG_F("UNREAL: aniv file is ", a_path);
     ASSIMP_LOG_DEBUG_F("UNREAL: uc file is ", uc_path);
 
@@ -174,8 +249,8 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
     // collect triangles
     std::vector<Unreal::Triangle> triangles(numTris);
-    for (auto & tri : triangles) {
+    for (auto &tri : triangles) {
-        for (unsigned int i = 0; i < 3;++i) {
+        for (unsigned int i = 0; i < 3; ++i) {
 
             tri.mVertex[i] = d_reader.GetI2();
             if (tri.mVertex[i] >= numTris) {
@@ -186,7 +261,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         tri.mType = d_reader.GetI1();
 
         // handle mesh flagss?
-        if (configHandleFlags)
+        if (mConfigHandleFlags)
             tri.mType = Unreal::MF_NORMAL_OS;
         else {
             // ignore MOD and MASKED for the moment, treat them as two-sided
@@ -195,12 +270,12 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         }
         d_reader.IncPtr(1);
 
-        for (unsigned int i = 0; i < 3;++i)
+        for (unsigned int i = 0; i < 3; ++i)
-            for (unsigned int i2 = 0; i2 < 2;++i2)
+            for (unsigned int i2 = 0; i2 < 2; ++i2)
                 tri.mTex[i][i2] = d_reader.GetI1();
 
         tri.mTextureNum = d_reader.GetI1();
-        maxTexIdx = std::max(maxTexIdx,(unsigned int)tri.mTextureNum);
+        maxTexIdx = std::max(maxTexIdx, (unsigned int)tri.mTextureNum);
         d_reader.IncPtr(1);
     }
 
@@ -211,63 +286,64 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
     // read number of frames
     const uint32_t numFrames = a_reader.GetI2();
-    if (configFrameID >= numFrames) {
+    if (mConfigFrameID >= numFrames) {
         throw DeadlyImportError("UNREAL: The requested frame does not exist");
     }
 
     uint32_t st = a_reader.GetI2();
-    if (st != numVert*4u)
+    if (st != numVert * 4u)
         throw DeadlyImportError("UNREAL: Unexpected aniv file length");
 
     // skip to our frame
-    a_reader.IncPtr(configFrameID *numVert*4);
+    a_reader.IncPtr(mConfigFrameID * numVert * 4);
 
     // collect vertices
     std::vector<aiVector3D> vertices(numVert);
     for (auto &vertex : vertices) {
         int32_t val = a_reader.GetI4();
-        Unreal::DecompressVertex(vertex ,val);
+        Unreal::DecompressVertex(vertex, val);
     }
 
     // list of textures.
-    std::vector< std::pair<unsigned int, std::string> > textures;
+    std::vector<std::pair<unsigned int, std::string>> textures;
 
     // allocate the output scene
-    aiNode* nd = pScene->mRootNode = new aiNode();
+    aiNode *nd = pScene->mRootNode = new aiNode();
     nd->mName.Set("<UnrealRoot>");
 
     // we can live without the uc file if necessary
-    std::unique_ptr<IOStream> pb (pIOHandler->Open(uc_path));
+    std::unique_ptr<IOStream> pb(pIOHandler->Open(uc_path));
     if (pb.get()) {
 
         std::vector<char> _data;
-        TextFileToBuffer(pb.get(),_data);
+        TextFileToBuffer(pb.get(), _data);
-        const char* data = &_data[0];
+        const char *data = &_data[0];
 
-        std::vector< std::pair< std::string,std::string > > tempTextures;
+        std::vector<std::pair<std::string, std::string>> tempTextures;
 
         // do a quick search in the UC file for some known, usually texture-related, tags
-        for (;*data;++data) {
+        for (; *data; ++data) {
-            if (TokenMatchI(data,"#exec",5))    {
+            if (TokenMatchI(data, "#exec", 5)) {
                 SkipSpacesAndLineEnd(&data);
 
                 // #exec TEXTURE IMPORT [...] NAME=jjjjj [...] FILE=jjjj.pcx [...]
-                if (TokenMatchI(data,"TEXTURE",7))  {
+                if (TokenMatchI(data, "TEXTURE", 7)) {
                     SkipSpacesAndLineEnd(&data);
 
-                    if (TokenMatchI(data,"IMPORT",6))   {
+                    if (TokenMatchI(data, "IMPORT", 6)) {
-                        tempTextures.push_back(std::pair< std::string,std::string >());
+                        tempTextures.push_back(std::pair<std::string, std::string>());
-                        std::pair< std::string,std::string >& me = tempTextures.back();
+                        std::pair<std::string, std::string> &me = tempTextures.back();
-                        for (;!IsLineEnd(*data);++data) {
+                        for (; !IsLineEnd(*data); ++data) {
-                            if (!::ASSIMP_strincmp(data,"NAME=",5)) {
+                            if (!::ASSIMP_strincmp(data, "NAME=", 5)) {
-                                const char *d = data+=5;
+                                const char *d = data += 5;
-                                for (;!IsSpaceOrNewLine(*data);++data);
+                                for (; !IsSpaceOrNewLine(*data); ++data)
-                                me.first = std::string(d,(size_t)(data-d));
+                                    ;
-                            }
+                                me.first = std::string(d, (size_t)(data - d));
-                            else if (!::ASSIMP_strincmp(data,"FILE=",5))    {
+                            } else if (!::ASSIMP_strincmp(data, "FILE=", 5)) {
-                                const char *d = data+=5;
+                                const char *d = data += 5;
-                                for (;!IsSpaceOrNewLine(*data);++data);
+                                for (; !IsSpaceOrNewLine(*data); ++data)
-                                me.second = std::string(d,(size_t)(data-d));
+                                    ;
+                                me.second = std::string(d, (size_t)(data - d));
                             }
                         }
                         if (!me.first.length() || !me.second.length())
@@ -276,27 +352,27 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                 }
                 // #exec MESHMAP SETTEXTURE MESHMAP=box NUM=1 TEXTURE=Jtex1
                 // #exec MESHMAP SCALE MESHMAP=box X=0.1 Y=0.1 Z=0.2
-                else if (TokenMatchI(data,"MESHMAP",7)) {
+                else if (TokenMatchI(data, "MESHMAP", 7)) {
                     SkipSpacesAndLineEnd(&data);
 
-                    if (TokenMatchI(data,"SETTEXTURE",10)) {
+                    if (TokenMatchI(data, "SETTEXTURE", 10)) {
 
                         textures.push_back(std::pair<unsigned int, std::string>());
-                        std::pair<unsigned int, std::string>& me = textures.back();
+                        std::pair<unsigned int, std::string> &me = textures.back();
 
-                        for (;!IsLineEnd(*data);++data) {
+                        for (; !IsLineEnd(*data); ++data) {
-                            if (!::ASSIMP_strincmp(data,"NUM=",4))  {
+                            if (!::ASSIMP_strincmp(data, "NUM=", 4)) {
                                 data += 4;
-                                me.first = strtoul10(data,&data);
+                                me.first = strtoul10(data, &data);
-                            }
+                            } else if (!::ASSIMP_strincmp(data, "TEXTURE=", 8)) {
-                            else if (!::ASSIMP_strincmp(data,"TEXTURE=",8)) {
                                 data += 8;
                                 const char *d = data;
-                                for (;!IsSpaceOrNewLine(*data);++data);
+                                for (; !IsSpaceOrNewLine(*data); ++data)
-                                me.second = std::string(d,(size_t)(data-d));
+                                    ;
+                                me.second = std::string(d, (size_t)(data - d));
 
                                 // try to find matching path names, doesn't care if we don't find them
-                                for (std::vector< std::pair< std::string,std::string > >::const_iterator it = tempTextures.begin();
+                                for (std::vector<std::pair<std::string, std::string>>::const_iterator it = tempTextures.begin();
                                         it != tempTextures.end(); ++it) {
                                     if ((*it).first == me.second) {
                                         me.second = (*it).second;
@@ -305,36 +381,32 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                                 }
                             }
                         }
-                    }
+                    } else if (TokenMatchI(data, "SCALE", 5)) {
-                    else if (TokenMatchI(data,"SCALE",5)) {
 
-                        for (;!IsLineEnd(*data);++data) {
+                        for (; !IsLineEnd(*data); ++data) {
                             if (data[0] == 'X' && data[1] == '=') {
-                                data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.a1);
+                                data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.a1);
-                            }
+                            } else if (data[0] == 'Y' && data[1] == '=') {
-                            else if (data[0] == 'Y' && data[1] == '=')  {
+                                data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.b2);
-                                data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.b2);
+                            } else if (data[0] == 'Z' && data[1] == '=') {
-                            }
+                                data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.c3);
-                            else if (data[0] == 'Z' && data[1] == '=')  {
-                                data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.c3);
                             }
                         }
                     }
                 }
             }
         }
-    }
+    } else {
-    else    {
         ASSIMP_LOG_ERROR("Unable to open .uc file");
     }
 
     std::vector<Unreal::TempMat> materials;
-    materials.reserve(textures.size()*2+5);
+    materials.reserve(textures.size() * 2 + 5);
 
     // find out how many output meshes and materials we'll have and build material indices
     for (Unreal::Triangle &tri : triangles) {
         Unreal::TempMat mat(tri);
-        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat);
+        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(), materials.end(), mat);
         if (nt == materials.end()) {
             // add material
             tri.matIndex = static_cast<unsigned int>(materials.size());
@@ -342,9 +414,8 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
             materials.push_back(mat);
 
             ++pScene->mNumMeshes;
-        }
+        } else {
-        else {
+            tri.matIndex = static_cast<unsigned int>(nt - materials.begin());
-            tri.matIndex = static_cast<unsigned int>(nt-materials.begin());
             ++nt->numFaces;
         }
     }
@@ -354,65 +425,65 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
     }
 
     // allocate meshes and bind them to the node graph
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes];
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = pScene->mNumMeshes];
 
     nd->mNumMeshes = pScene->mNumMeshes;
     nd->mMeshes = new unsigned int[nd->mNumMeshes];
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        aiMesh* m = pScene->mMeshes[i] =  new aiMesh();
+        aiMesh *m = pScene->mMeshes[i] = new aiMesh();
         m->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
         const unsigned int num = materials[i].numFaces;
-        m->mFaces            = new aiFace     [num];
+        m->mFaces = new aiFace[num];
-        m->mVertices         = new aiVector3D [num*3];
+        m->mVertices = new aiVector3D[num * 3];
-        m->mTextureCoords[0] = new aiVector3D [num*3];
+        m->mTextureCoords[0] = new aiVector3D[num * 3];
 
         nd->mMeshes[i] = i;
 
         // create materials, too
-        aiMaterial* mat = new aiMaterial();
+        aiMaterial *mat = new aiMaterial();
         pScene->mMaterials[i] = mat;
 
         // all white by default - texture rulez
-        aiColor3D color(1.f,1.f,1.f);
+        aiColor3D color(1.f, 1.f, 1.f);
 
         aiString s;
-        ::ai_snprintf( s.data, MAXLEN, "mat%u_tx%u_",i,materials[i].tex );
+        ::ai_snprintf(s.data, MAXLEN, "mat%u_tx%u_", i, materials[i].tex);
 
         // set the two-sided flag
         if (materials[i].type == Unreal::MF_NORMAL_TS) {
             const int twosided = 1;
-            mat->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED);
+            mat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
-            ::strcat(s.data,"ts_");
+            ::strcat(s.data, "ts_");
-        }
+        } else
-        else ::strcat(s.data,"os_");
+            ::strcat(s.data, "os_");
 
         // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us
         if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) {
             const float opac = 0.9f;
-            mat->AddProperty(&opac,1,AI_MATKEY_OPACITY);
+            mat->AddProperty(&opac, 1, AI_MATKEY_OPACITY);
-            ::strcat(s.data,"tran_");
+            ::strcat(s.data, "tran_");
-        }
+        } else
-        else ::strcat(s.data,"opaq_");
+            ::strcat(s.data, "opaq_");
 
         // a special name for the weapon attachment point
         if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) {
-            s.length = ::ai_snprintf( s.data, MAXLEN, "$WeaponTag$" );
+            s.length = ::ai_snprintf(s.data, MAXLEN, "$WeaponTag$");
-            color = aiColor3D(0.f,0.f,0.f);
+            color = aiColor3D(0.f, 0.f, 0.f);
         }
 
         // set color and name
-        mat->AddProperty(&color,1,AI_MATKEY_COLOR_DIFFUSE);
+        mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
-        s.length = (ai_uint32)::strlen(s.data);
+        s.length = static_cast<ai_uint32>(::strlen(s.data));
-        mat->AddProperty(&s,AI_MATKEY_NAME);
+        mat->AddProperty(&s, AI_MATKEY_NAME);
 
         // set texture, if any
         const unsigned int tex = materials[i].tex;
-        for (std::vector< std::pair< unsigned int, std::string > >::const_iterator it = textures.begin();it != textures.end();++it) {
+        for (std::vector<std::pair<unsigned int, std::string>>::const_iterator it = textures.begin(); it != textures.end(); ++it) {
             if ((*it).first == tex) {
                 s.Set((*it).second);
-                mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+                mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
                 break;
             }
         }
@@ -421,17 +492,17 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
     // fill them.
     for (const Unreal::Triangle &tri : triangles) {
         Unreal::TempMat mat(tri);
-        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat);
+        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(), materials.end(), mat);
 
-        aiMesh* mesh = pScene->mMeshes[nt-materials.begin()];
+        aiMesh *mesh = pScene->mMeshes[nt - materials.begin()];
-        aiFace& f    = mesh->mFaces[mesh->mNumFaces++];
+        aiFace &f = mesh->mFaces[mesh->mNumFaces++];
         f.mIndices = new unsigned int[f.mNumIndices = 3];
 
-        for (unsigned int i = 0; i < 3;++i,mesh->mNumVertices++) {
+        for (unsigned int i = 0; i < 3; ++i, mesh->mNumVertices++) {
             f.mIndices[i] = mesh->mNumVertices;
 
-            mesh->mVertices[mesh->mNumVertices] = vertices[ tri.mVertex[i] ];
+            mesh->mVertices[mesh->mNumVertices] = vertices[tri.mVertex[i]];
-            mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D( tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f);
+            mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D(tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f);
         }
     }
 

code/Unreal/UnrealLoader.h

@@ -4,7 +4,6 @@ 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,
@@ -47,161 +46,57 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_3D_LOADER_H
 
 #include <assimp/BaseImporter.h>
-#include <stdint.h>
 
 namespace Assimp {
-namespace Unreal {
-
-    /*
-    0 = Normal one-sided
-    1 = Normal two-sided
-    2 = Translucent two-sided
-    3 = Masked two-sided
-    4 = Modulation blended two-sided
-    8 = Placeholder triangle for weapon positioning (invisible)
-    */
-enum MeshFlags {
-    MF_NORMAL_OS            = 0,
-    MF_NORMAL_TS            = 1,
-    MF_NORMAL_TRANS_TS      = 2,
-    MF_NORMAL_MASKED_TS     = 3,
-    MF_NORMAL_MOD_TS        = 4,
-    MF_WEAPON_PLACEHOLDER   = 8
-};
-
-    // a single triangle
-struct Triangle {
-   uint16_t mVertex[3];       // Vertex indices
-   char mType;                // James' Mesh Type
-   char mColor;               // Color for flat and Gourand Shaded
-   unsigned char mTex[3][2];  // Texture UV coordinates
-   unsigned char mTextureNum; // Source texture offset
-   char mFlags;               // Unreal Mesh Flags (unused)
-
-   unsigned int matIndex;
-};
-
-// temporary representation for a material
-struct TempMat  {
-    TempMat()
-        :   type()
-        ,   tex()
-        ,   numFaces    (0)
-    {}
-
-    explicit TempMat(const Triangle& in)
-        :   type        ((Unreal::MeshFlags)in.mType)
-        ,   tex         (in.mTextureNum)
-        ,   numFaces    (0)
-    {}
-
-    // type of mesh
-    Unreal::MeshFlags type;
-
-    // index of texture
-    unsigned int tex;
-
-    // number of faces using us
-    unsigned int numFaces;
-
-    // for std::find
-    bool operator == (const TempMat& o )    {
-        return (tex == o.tex && type == o.type);
-    }
-};
-
-struct Vertex
-{
-    int32_t X : 11;
-    int32_t Y : 11;
-    int32_t Z : 10;
-};
-
-    // UNREAL vertex compression
-inline void CompressVertex(const aiVector3D& v, uint32_t& out)
-{
-    union {
-        Vertex n;
-        int32_t t;
-    };
-    n.X = (int32_t)v.x;
-    n.Y = (int32_t)v.y;
-    n.Z = (int32_t)v.z;
-    ::memcpy( &out, &t, sizeof(int32_t));
-    //out = t;
-}
-
-    // UNREAL vertex decompression
-inline void DecompressVertex(aiVector3D& v, int32_t in)
-{
-    union {
-        Vertex n;
-        int32_t i;
-    };
-    i = in;
-
-    v.x = (float)n.X;
-    v.y = (float)n.Y;
-    v.z = (float)n.Z;
-}
-
-} // end namespace Unreal
 
 // ---------------------------------------------------------------------------
 /** @brief Importer class to load UNREAL files (*.3d)
 */
-class UnrealImporter : public BaseImporter
+class UnrealImporter : public BaseImporter {
-{
 public:
     UnrealImporter();
     ~UnrealImporter();
 
-
-public:
-
     // -------------------------------------------------------------------
     /** @brief Returns whether we can handle the format of the given file
      *
      *  See BaseImporter::CanRead() for details.
      **/
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
             bool checkSig) const;
 
 protected:
-
     // -------------------------------------------------------------------
     /** @brief Called by Importer::GetExtensionList()
      *
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const;
-
 
     // -------------------------------------------------------------------
     /** @brief Setup properties for the importer
      *
      * See BaseImporter::SetupProperties() for details
      */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp);
-
 
     // -------------------------------------------------------------------
     /** @brief Imports the given file into the given scene structure.
      *
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
-        IOSystem* pIOHandler);
+            IOSystem *pIOHandler);
 
 private:
-
     //! frame to be loaded
-    uint32_t configFrameID;
+    uint32_t mConfigFrameID;
 
     //! process surface flags
-    bool configHandleFlags;
+    bool mConfigHandleFlags;
 
 }; // !class UnrealImporter
 
 } // end of namespace Assimp
+
 #endif // AI_UNREALIMPORTER_H_INC

code/XGL/XGLLoader.cpp

@@ -176,7 +176,7 @@ void XGLImporter::InternReadFile( const std::string& pFile,
         raw_reader->IncPtr(2);
 
         zstream.next_in   = reinterpret_cast<Bytef*>( raw_reader->GetPtr() );
-        zstream.avail_in  = raw_reader->GetRemainingSize();
+        zstream.avail_in  = (uInt) raw_reader->GetRemainingSize();
 
         size_t total = 0l;
 

contrib/irrXML/CMakeLists.txt

@@ -15,7 +15,11 @@ if ( MSVC )
 endif ( MSVC )
 
 IF(CMAKE_SYSTEM_NAME MATCHES "(Darwin|FreeBSD)")
+  IF(APPLE)
+    add_library(IrrXML STATIC ${IrrXML_SRCS})
+  ELSE()
     add_library(IrrXML ${IrrXML_SRCS})
+  ENDIF()
 ELSE()
   add_library(IrrXML STATIC ${IrrXML_SRCS})
 ENDIF()

contrib/irrXML/CXMLReaderImpl.h

@@ -8,16 +8,7 @@
 #include "irrXML.h"
 #include "irrString.h"
 #include "irrArray.h"
-
+#include "fast_atof.h"
-#include <cassert>
-#include <stdlib.h>    
-#include <cctype>
-#include <cstdint>
-//using namespace Assimp;
-
-// For locale independent number conversion
-#include <sstream>
-#include <locale>
 
 #ifdef _DEBUG
 #define IRR_DEBUGPRINT(x) printf((x));
@@ -37,14 +28,23 @@ template<class char_type, class superclass>
 class CXMLReaderImpl : public IIrrXMLReader<char_type, superclass>
 {
 public:
-
 	//! Constructor
 	CXMLReaderImpl(IFileReadCallBack* callback, bool deleteCallBack = true) 
-		: TextData(0), P(0), TextBegin(0), TextSize(0), CurrentNodeType(EXN_NONE),
+	: TextData(0)
-		SourceFormat(ETF_ASCII), TargetFormat(ETF_ASCII)
+	, P(0)
-	{
+	, TextBegin(0)
-		if (!callback)
+	, TextSize(0)
+	, CurrentNodeType(EXN_NONE)
+	, SourceFormat(ETF_ASCII)
+	, TargetFormat(ETF_ASCII)
+	, NodeName ()
+	, EmptyString()
+	, IsEmptyElement(false)
+	, SpecialCharacters()
+	, Attributes() {
+		if (!callback) {
 			return;
+		}
 
 		storeTargetFormat();
 
@@ -168,8 +168,7 @@ public:
 			return 0;
 
 		core::stringc c = attr->Value.c_str();
-        return static_cast<float>(atof(c.c_str()));
+		return core::fast_atof(c.c_str());
-        //return fast_atof(c.c_str());
 	}
 
 
@@ -181,11 +180,7 @@ public:
 			return 0;
 
 		core::stringc c = attrvalue;
-		std::istringstream sstr(c.c_str());
+		return core::fast_atof(c.c_str());
-		sstr.imbue(std::locale("C")); // Locale free number convert
-		float fNum;
-		sstr >> fNum;
-		return fNum;
 	}
 
 
@@ -228,7 +223,7 @@ private:
 	{
 		char_type* start = P;
 
-		// move forward until '<' found
+		// more forward until '<' found
 		while(*P != L'<' && *P)
 			++P;
 
@@ -438,10 +433,6 @@ private:
 		while(*P != L'>')
 			++P;
 
-    // remove trailing whitespace, if any
-    while( std::isspace( P[-1]))
-      --P;
-
 		NodeName = core::string<char_type>(pBeginClose, (int)(P - pBeginClose));
 		++P;
 	}
@@ -676,12 +667,8 @@ private:
 
 			TextData = new char_type[sizeWithoutHeader];
 
-			// MSVC debugger complains here about loss of data ...
-			size_t numShift = sizeof( char_type) * 8;
-			assert(numShift < 64);
-			const src_char_type cc = (src_char_type)(((uint64_t(1u) << numShift) - 1));
 			for (int i=0; i<sizeWithoutHeader; ++i)
-				TextData[i] = char_type( source[i] & cc); 
+				TextData[i] = (char_type)source[i];
 
 			TextBegin = TextData;
 			TextSize = sizeWithoutHeader;

contrib/irrXML/fast_atof.h

@@ -0,0 +1,139 @@
+// Copyright (C) 2002-2005 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine" and the "irrXML" project.
+// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
+
+#ifndef __FAST_A_TO_F_H_INCLUDED__
+#define __FAST_A_TO_F_H_INCLUDED__
+
+#include <stdlib.h>
+#include <math.h>
+
+namespace irr
+{
+namespace core
+{
+
+const float fast_atof_table[] =	{
+										0.f,
+										0.1f,
+										0.01f,
+										0.001f,
+										0.0001f,
+										0.00001f,
+										0.000001f,
+										0.0000001f,
+										0.00000001f,
+										0.000000001f,
+										0.0000000001f,
+										0.00000000001f,
+										0.000000000001f,
+										0.0000000000001f,
+										0.00000000000001f,
+										0.000000000000001f
+									};
+
+//! Provides a fast function for converting a string into a float,
+//! about 6 times faster than atof in win32.
+// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
+inline char* fast_atof_move(char* c, float& out)
+{
+	bool inv = false;
+	char *t;
+	float f;
+
+	if (*c=='-')
+	{
+		c++;
+		inv = true;
+	}
+
+	f = (float)strtol(c, &t, 10);
+
+	c = t;
+
+	if (*c == '.')
+	{
+		c++;
+
+		float pl = (float)strtol(c, &t, 10);
+		pl *= fast_atof_table[t-c];
+
+		f += pl;
+
+		c = t;
+
+		if (*c == 'e')
+		{
+			++c;
+			float exp = (float)strtol(c, &t, 10);
+			f *= (float)pow(10.0f, exp);
+			c = t;
+		}
+	}
+
+	if (inv)
+		f *= -1.0f;
+	
+	out = f;
+	return c;
+}
+
+//! Provides a fast function for converting a string into a float,
+//! about 6 times faster than atof in win32.
+// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
+inline const char* fast_atof_move_const(const char* c, float& out)
+{
+	bool inv = false;
+	char *t;
+	float f;
+
+	if (*c=='-')
+	{
+		c++;
+		inv = true;
+	}
+
+	f = (float)strtol(c, &t, 10);
+
+	c = t;
+
+	if (*c == '.')
+	{
+		c++;
+
+		float pl = (float)strtol(c, &t, 10);
+		pl *= fast_atof_table[t-c];
+
+		f += pl;
+
+		c = t;
+
+		if (*c == 'e') 
+		{ 
+			++c; 
+			f32 exp = (f32)strtol(c, &t, 10); 
+			f *= (f32)powf(10.0f, exp); 
+			c = t; 
+		}
+	}
+
+	if (inv)
+		f *= -1.0f;
+	
+	out = f;
+	return c;
+}
+
+
+inline float fast_atof(const char* c)
+{
+	float ret;
+	fast_atof_move_const(c, ret);
+	return ret;
+}
+
+} // end namespace core
+}// end namespace irr
+
+#endif
+

contrib/irrXML/irrArray.h

@@ -21,6 +21,7 @@ class array
 {
 
 public:
+
 	array()
 		: data(0), allocated(0), used(0),
 			free_when_destroyed(true), is_sorted(true)

contrib/irrXML/irrString.h

@@ -117,7 +117,7 @@ public:
 	//! Constructor for unicode and ascii strings
 	template <class B>
 	string(const B* c)
-	: array(0),allocated(0), used(0)
+	: array(0), allocated(0), used(0)
 	{
 		*this = c;
 	}

contrib/irrXML/irrTypes.h

@@ -79,13 +79,8 @@ typedef unsigned short wchar_t;
 #endif // microsoft compiler
 
 //! define a break macro for debugging only in Win32 mode.
-// WORKAROUND (assimp): remove __asm
+#if !defined(_WIN64) && defined(WIN32) && defined(_MSC_VER) && defined(_DEBUG)
-#if defined(WIN32) && defined(_MSC_VER) && defined(_DEBUG)
+#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) if (_CONDITION_) {_asm int 3}
-#if defined(_M_IX86)
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) /*if (_CONDITION_) {_asm int 3}*/
-#else
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ )
-#endif
 #else 
 #define _IRR_DEBUG_BREAK_IF( _CONDITION_ )
 #endif
@@ -96,10 +91,8 @@ When you call unmanaged code that returns a bool type value of false from manage
 the return value may appear as true. See 
 http://support.microsoft.com/default.aspx?kbid=823071 for details. 
 Compiler version defines: VC6.0 : 1200, VC7.0 : 1300, VC7.1 : 1310, VC8.0 : 1400*/
-
+#if !defined(_WIN64) && defined(WIN32) && defined(_MSC_VER) && (_MSC_VER > 1299) && (_MSC_VER < 1400)
-// WORKAROUND (assimp): remove __asm 
+#define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX __asm mov eax,100
-#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER > 1299) && (_MSC_VER < 1400)
-#define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX /*__asm mov eax,100*/
 #else
 #define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX
 #endif // _IRR_MANAGED_MARSHALLING_BUGFIX

contrib/irrXML/irrXML.cpp

@@ -2,14 +2,10 @@
 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
 // For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
 
-// Need to include Assimp, too. We're using Assimp's version of fast_atof
-// so we need stdint.h. But no PCH.
-
-
 #include "irrXML.h"
 #include "irrString.h"
 #include "irrArray.h"
-//#include <assimp/fast_atof.h>
+#include "fast_atof.h"
 #include "CXMLReaderImpl.h"
 
 namespace irr
@@ -18,7 +14,7 @@ namespace io
 {
 
 //! Implementation of the file read callback for ordinary files
-class IRRXML_API CFileReadCallBack : public IFileReadCallBack
+class CFileReadCallBack : public IFileReadCallBack
 {
 public:
 

contrib/irrXML/irrXML.h

@@ -7,12 +7,6 @@
 
 #include <stdio.h>
 
-#ifdef _WIN32
-#   define IRRXML_API __declspec(dllexport)
-#else
-#   define IRRXML_API __attribute__ ((visibility("default")))
-#endif // _WIN32
-
 /** \mainpage irrXML 1.2 API documentation
  <div align="center"><img src="logobig.png" ></div>
 
@@ -178,7 +172,7 @@ namespace io
 		ETF_UTF32_BE,
 
 		//! UTF-32 format, little endian
-		ETF_UTF32_LE
+		ETF_UTF32_LE,
 	};
 
 
@@ -215,7 +209,7 @@ namespace io
 	two methods to read your data and give a pointer to an instance of
 	your implementation when calling createIrrXMLReader(), 
 	createIrrXMLReaderUTF16() or createIrrXMLReaderUTF32() */
-	class IRRXML_API IFileReadCallBack
+	class IFileReadCallBack
 	{
 	public:
 
@@ -415,7 +409,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(const char* filename);
+	IrrXMLReader* createIrrXMLReader(const char* filename);
 
 	//! Creates an instance of an UFT-8 or ASCII character xml parser.
 	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can 
@@ -427,7 +421,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(FILE* file);
+	IrrXMLReader* createIrrXMLReader(FILE* file);
 
 	//! Creates an instance of an UFT-8 or ASCII character xml parser. 
 	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can 
@@ -440,7 +434,7 @@ namespace io
 	 \return Returns a pointer to the created xml parser. This pointer should be 
 	 deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	 and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback);
+	IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback);
 
 	//! Creates an instance of an UFT-16 xml parser. 
 	/** This means that
@@ -452,7 +446,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename);
+	IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename);
 
 	//! Creates an instance of an UFT-16 xml parser. 
 	/** This means that all character data will be returned in UTF-16. The file to read can 
@@ -464,7 +458,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file);
+	IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file);
 
 	//! Creates an instance of an UFT-16 xml parser. 
 	/** This means that all character data will be returned in UTF-16. The file to read can 
@@ -477,7 +471,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback);
+	IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback);
 
 
 	//! Creates an instance of an UFT-32 xml parser. 
@@ -489,7 +483,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename);
+	IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename);
 
 	//! Creates an instance of an UFT-32 xml parser. 
 	/** This means that all character data will be returned in UTF-32. The file to read can 
@@ -501,7 +495,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file);
+	IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file);
 
 	//! Creates an instance of an UFT-32 xml parser. 
 	/** This means that
@@ -515,7 +509,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback);
+	IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback);
 	
 
 	/*! \file irrxml.h

include/assimp/StreamReader.h

@@ -5,8 +5,6 @@ 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,
@@ -49,13 +47,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_STREAMREADER_H_INCLUDED
 
 #ifdef __GNUC__
-#   pragma GCC system_header
+#pragma GCC system_header
 #endif
 
-#include <assimp/IOStream.hpp>
-#include <assimp/Defines.h>
 #include <assimp/ByteSwapper.h>
+#include <assimp/Defines.h>
 #include <assimp/Exceptional.h>
+#include <assimp/IOStream.hpp>
 
 #include <memory>
 
@@ -74,10 +72,8 @@ namespace Assimp {
 template <bool SwapEndianess = false, bool RuntimeSwitch = false>
 class StreamReader {
 public:
-    // FIXME: use these data types throughout the whole library,
+    using diff = size_t;
-    // then change them to 64 bit values :-)
+    using pos = size_t;
-    using diff = int;
-    using pos  = unsigned int;
 
     // ---------------------------------------------------------------------
     /** Construction from a given stream with a well-defined endianness.
@@ -91,39 +87,44 @@ public:
      *    stream is in little endian byte order. Otherwise the
      *    endianness information is contained in the @c SwapEndianess
      *    template parameter and this parameter is meaningless.  */
-    StreamReader(std::shared_ptr<IOStream> stream, bool le = false)
+    StreamReader(std::shared_ptr<IOStream> stream, bool le = false) :
-        : stream(stream)
+            mStream(stream),
-        , le(le)
+            mBuffer(nullptr),
-    {
+            mCurrent(nullptr),
+            mEnd(nullptr),
+            mLimit(nullptr),
+            mLe(le) {
         ai_assert(stream);
         InternBegin();
     }
 
     // ---------------------------------------------------------------------
-    StreamReader(IOStream* stream, bool le = false)
+    StreamReader(IOStream *stream, bool le = false) :
-        : stream(std::shared_ptr<IOStream>(stream))
+            mStream(std::shared_ptr<IOStream>(stream)),
-        , le(le)
+            mBuffer(nullptr),
-    {
+            mCurrent(nullptr),
-        ai_assert(stream);
+            mEnd(nullptr),
+            mLimit(nullptr),
+            mLe(le) {
+        ai_assert(nullptr != stream);
         InternBegin();
     }
 
     // ---------------------------------------------------------------------
     ~StreamReader() {
-        delete[] buffer;
+        delete[] mBuffer;
     }
 
     // deprecated, use overloaded operator>> instead
 
     // ---------------------------------------------------------------------
-    /** Read a float from the stream  */
+    /// Read a float from the stream.
-    float GetF4()
+    float GetF4() {
-    {
         return Get<float>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a double from the stream  */
+    /// Read a double from the stream.
     double GetF8() {
         return Get<double>();
     }
@@ -159,50 +160,50 @@ public:
     }
 
     // ---------------------------------------------------------------------
-    /** Read a unsigned 8 bit integer from the stream */
+    /// Read a unsigned 8 bit integer from the stream
     uint8_t GetU1() {
         return Get<uint8_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read an unsigned 32 bit integer from the stream */
+    /// Read an unsigned 32 bit integer from the stream
     uint32_t GetU4() {
         return Get<uint32_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a unsigned 64 bit integer from the stream */
+    /// Read a unsigned 64 bit integer from the stream
     uint64_t GetU8() {
         return Get<uint64_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Get the remaining stream size (to the end of the stream) */
+    /// Get the remaining stream size (to the end of the stream)
-    unsigned int GetRemainingSize() const {
+    size_t GetRemainingSize() const {
-        return (unsigned int)(end - current);
+        return (unsigned int)(mEnd - mCurrent);
     }
 
     // ---------------------------------------------------------------------
     /** Get the remaining stream size (to the current read limit). The
      *  return value is the remaining size of the stream if no custom
      *  read limit has been set. */
-    unsigned int GetRemainingSizeToLimit() const {
+    size_t GetRemainingSizeToLimit() const {
-        return (unsigned int)(limit - current);
+        return (unsigned int)(mLimit - mCurrent);
     }
 
     // ---------------------------------------------------------------------
     /** Increase the file pointer (relative seeking)  */
     void IncPtr(intptr_t plus) {
-        current += plus;
+        mCurrent += plus;
-        if (current > limit) {
+        if (mCurrent > mLimit) {
             throw DeadlyImportError("End of file or read limit was reached");
         }
     }
 
     // ---------------------------------------------------------------------
     /** Get the current file pointer */
-    int8_t* GetPtr() const  {
+    int8_t *GetPtr() const {
-        return current;
+        return mCurrent;
     }
 
     // ---------------------------------------------------------------------
@@ -211,9 +212,9 @@ public:
      *  large chunks of data at once.
      *  @param p The new pointer, which is validated against the size
      *    limit and buffer boundaries. */
-    void SetPtr(int8_t* p)  {
+    void SetPtr(int8_t *p) {
-        current = p;
+        mCurrent = p;
-        if (current > limit || current < buffer) {
+        if (mCurrent > mLimit || mCurrent < mBuffer) {
             throw DeadlyImportError("End of file or read limit was reached");
         }
     }
@@ -222,21 +223,20 @@ public:
     /** Copy n bytes to an external buffer
      *  @param out Destination for copying
      *  @param bytes Number of bytes to copy */
-    void CopyAndAdvance(void* out, size_t bytes)    {
+    void CopyAndAdvance(void *out, size_t bytes) {
-        int8_t* ur = GetPtr();
+        int8_t *ur = GetPtr();
-        SetPtr(ur+bytes); // fire exception if eof
+        SetPtr(ur + bytes); // fire exception if eof
 
-        ::memcpy(out,ur,bytes);
+        ::memcpy(out, ur, bytes);
     }
 
-    // ---------------------------------------------------------------------
+    /// @brief Get the current offset from the beginning of the file
-    /** Get the current offset from the beginning of the file */
     int GetCurrentPos() const {
-        return (unsigned int)(current - buffer);
+        return (unsigned int)(mCurrent - mBuffer);
     }
 
     void SetCurrentPos(size_t pos) {
-        SetPtr(buffer + pos);
+        SetPtr(mBuffer + pos);
     }
 
     // ---------------------------------------------------------------------
@@ -249,12 +249,12 @@ public:
     unsigned int SetReadLimit(unsigned int _limit) {
         unsigned int prev = GetReadLimit();
         if (UINT_MAX == _limit) {
-            limit = end;
+            mLimit = mEnd;
             return prev;
         }
 
-        limit = buffer + _limit;
+        mLimit = mBuffer + _limit;
-        if (limit > end) {
+        if (mLimit > mEnd) {
             throw DeadlyImportError("StreamReader: Invalid read limit");
         }
         return prev;
@@ -264,20 +264,20 @@ public:
     /** Get the current read limit in bytes. Reading over this limit
      *  accidentally raises an exception.  */
     unsigned int GetReadLimit() const {
-        return (unsigned int)(limit - buffer);
+        return (unsigned int)(mLimit - mBuffer);
     }
 
     // ---------------------------------------------------------------------
     /** Skip to the read limit in bytes. Reading over this limit
      *  accidentally raises an exception. */
     void SkipToReadLimit() {
-        current = limit;
+        mCurrent = mLimit;
     }
 
     // ---------------------------------------------------------------------
     /** overload operator>> and allow chaining of >> ops. */
     template <typename T>
-    StreamReader& operator >> (T& f) {
+    StreamReader &operator>>(T &f) {
         f = Get<T>();
         return *this;
     }
@@ -286,14 +286,14 @@ public:
     /** Generic read method. ByteSwap::Swap(T*) *must* be defined */
     template <typename T>
     T Get() {
-        if ( current + sizeof(T) > limit) {
+        if (mCurrent + sizeof(T) > mLimit) {
             throw DeadlyImportError("End of file or stream limit was reached");
         }
 
         T f;
-        ::memcpy (&f, current, sizeof(T));
+        ::memcpy(&f, mCurrent, sizeof(T));
-        Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le);
+        Intern::Getter<SwapEndianess, T, RuntimeSwitch>()(&f, mLe);
-        current += sizeof(T);
+        mCurrent += sizeof(T);
 
         return f;
     }
@@ -301,46 +301,44 @@ public:
 private:
     // ---------------------------------------------------------------------
     void InternBegin() {
-        if (!stream) {
+        if (nullptr == mStream) {
-            // in case someone wonders: StreamReader is frequently invoked with
-            // no prior validation whether the input stream is valid. Since
-            // no one bothers changing the error message, this message here
-            // is passed down to the caller and 'unable to open file'
-            // simply describes best what happened.
             throw DeadlyImportError("StreamReader: Unable to open file");
         }
 
-        const size_t s = stream->FileSize() - stream->Tell();
+        const size_t filesize = mStream->FileSize() - mStream->Tell();
-        if (!s) {
+        if (0 == filesize) {
             throw DeadlyImportError("StreamReader: File is empty or EOF is already reached");
         }
 
-        current = buffer = new int8_t[s];
+        mCurrent = mBuffer = new int8_t[filesize];
-        const size_t read = stream->Read(current,1,s);
+        const size_t read = mStream->Read(mCurrent, 1, filesize);
         // (read < s) can only happen if the stream was opened in text mode, in which case FileSize() is not reliable
-        ai_assert(read <= s);
+        ai_assert(read <= filesize);
-        end = limit = &buffer[read-1] + 1;
+        mEnd = mLimit = &mBuffer[read - 1] + 1;
     }
 
 private:
-    std::shared_ptr<IOStream> stream;
+    std::shared_ptr<IOStream> mStream;
-    int8_t *buffer, *current, *end, *limit;
+    int8_t *mBuffer;
-    bool le;
+    int8_t *mCurrent;
+    int8_t *mEnd;
+    int8_t *mLimit;
+    bool mLe;
 };
 
 // --------------------------------------------------------------------------------------------
 // `static` StreamReaders. Their byte order is fixed and they might be a little bit faster.
 #ifdef AI_BUILD_BIG_ENDIAN
-    typedef StreamReader<true>  StreamReaderLE;
+typedef StreamReader<true> StreamReaderLE;
-    typedef StreamReader<false> StreamReaderBE;
+typedef StreamReader<false> StreamReaderBE;
 #else
-    typedef StreamReader<true>  StreamReaderBE;
+typedef StreamReader<true> StreamReaderBE;
-    typedef StreamReader<false> StreamReaderLE;
+typedef StreamReader<false> StreamReaderLE;
 #endif
 
 // `dynamic` StreamReader. The byte order of the input data is specified in the
 // c'tor. This involves runtime branching and might be a little bit slower.
-typedef StreamReader<true,true> StreamReaderAny;
+typedef StreamReader<true, true> StreamReaderAny;
 
 } // end namespace Assimp
 

samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp

@@ -66,7 +66,7 @@ GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f };
 
 
 // the global Assimp scene object
-const aiScene* g_scene = NULL;
+const aiScene* g_scene = nullptr;
 GLuint scene_list = 0;
 aiVector3D scene_min, scene_max, scene_center;
 
@@ -124,7 +124,7 @@ bool Import3DFromFile( const std::string& pFile)
 	}
 	else
 	{
-		MessageBox(NULL, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
+		MessageBox(nullptr, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
 		logInfo( importer.GetErrorString());
 		return false;
 	}
@@ -181,7 +181,7 @@ void freeTextureIds()
 	if (textureIds)
 	{
 		delete[] textureIds;
-		textureIds = NULL;
+		textureIds = nullptr;
 	}
 }
 
@@ -217,7 +217,7 @@ int LoadGLTextures(const aiScene* scene)
 		while (texFound == AI_SUCCESS)
 		{
 			texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path);
-			textureIdMap[path.data] = NULL; //fill map with textures, pointers still NULL yet
+			textureIdMap[path.data] = nullptr; //fill map with textures, pointers still NULL yet
 			texIndex++;
 		}
 	}
@@ -285,7 +285,7 @@ int LoadGLTextures(const aiScene* scene)
 		else
 		{
 			/* Error occurred */
-			MessageBox(NULL, UTFConverter("Couldn't load Image: " + fileloc).c_wstr(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
+			MessageBox(nullptr, UTFConverter("Couldn't load Image: " + fileloc).c_wstr(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
 		}
 	}
     // Because we have already copied image data into texture data  we can release memory used by image.
@@ -447,7 +447,7 @@ void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float
 		apply_material(sc->mMaterials[mesh->mMaterialIndex]);
 
 
-		if(mesh->mNormals == NULL)
+		if(mesh->mNormals == nullptr)
 		{
 			glDisable(GL_LIGHTING);
 		}
@@ -456,7 +456,7 @@ void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float
 			glEnable(GL_LIGHTING);
 		}
 
-		if(mesh->mColors[0] != NULL)
+		if(mesh->mColors[0] != nullptr)
 		{
 			glEnable(GL_COLOR_MATERIAL);
 		}
@@ -482,9 +482,9 @@ void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float
 			for(i = 0; i < face->mNumIndices; i++)		// go through all vertices in face
 			{
 				int vertexIndex = face->mIndices[i];	// get group index for current index
-				if(mesh->mColors[0] != NULL)
+				if(mesh->mColors[0] != nullptr)
 					Color4f(&mesh->mColors[0][vertexIndex]);
-				if(mesh->mNormals != NULL)
+				if(mesh->mNormals != nullptr)
 
 					if(mesh->HasTextureCoords(0))		//HasTextureCoords(texture_coordinates_set)
 					{
@@ -543,50 +543,50 @@ void KillGLWindow()			// Properly Kill The Window
 {
 	if (fullscreen)					// Are We In Fullscreen Mode?
 	{
-		ChangeDisplaySettings(NULL, 0);		// If So Switch Back To The Desktop
+		ChangeDisplaySettings(nullptr, 0);	// If So Switch Back To The Desktop
 		ShowCursor(TRUE);					// Show Mouse Pointer
 	}
 
 	if (hRC)					// Do We Have A Rendering Context?
 	{
-		if (!wglMakeCurrent(NULL, NULL))	// Are We Able To Release The DC And RC Contexts?
+		if (!wglMakeCurrent(nullptr, nullptr))	// Are We Able To Release The DC And RC Contexts?
 		{
-			MessageBox(NULL, TEXT("Release Of DC And RC Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Release Of DC And RC Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
 		}
 
 		if (!wglDeleteContext(hRC))			// Are We Able To Delete The RC?
 		{
-			MessageBox(NULL, TEXT("Release Rendering Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Release Rendering Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
 		}
-		hRC = NULL;
+		hRC = nullptr;
 	}
 
 	if (hDC)
 	{
 		if (!ReleaseDC(g_hWnd, hDC)) // Are We able to Release The DC?
-			MessageBox(NULL, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
-		hDC = NULL;
+		hDC = nullptr;
 	}
 
 	if (g_hWnd)
 	{
 		if (!DestroyWindow(g_hWnd)) // Are We Able To Destroy The Window
-			MessageBox(NULL, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
-		g_hWnd = NULL;
+		g_hWnd = nullptr;
 	} 
 
 	if (g_hInstance)
 	{
 		if (!UnregisterClass(TEXT("OpenGL"), g_hInstance)) // Are We Able To Unregister Class
-			MessageBox(NULL, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
-		g_hInstance = NULL;
+		g_hInstance = nullptr;
 	}
 }
 
 GLboolean abortGLInit(const char* abortMessage)
 {
 	KillGLWindow();									// Reset Display
-	MessageBox(NULL, UTFConverter(abortMessage).c_wstr(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION);
+	MessageBox(nullptr, UTFConverter(abortMessage).c_wstr(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION);
 	return FALSE;									// quit and return False
 }
 
@@ -604,21 +604,21 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
 
 	fullscreen = fullscreenflag;
 
-	g_hInstance = GetModuleHandle(NULL);	// Grab An Instance For Our Window
+	g_hInstance = GetModuleHandle(nullptr);	// Grab An Instance For Our Window
 	wc.style		= CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Move, And Own DC For Window
 	wc.lpfnWndProc	= (WNDPROC) WndProc;		// WndProc handles Messages
 	wc.cbClsExtra	= 0;	// No Extra Window Data
 	wc.cbWndExtra	= 0;	// No Extra Window Data
 	wc.hInstance	= g_hInstance;
-	wc.hIcon		= LoadIcon(NULL, IDI_WINLOGO);	// Load The Default Icon
+	wc.hIcon		= LoadIcon(nullptr, IDI_WINLOGO);	// Load The Default Icon
-	wc.hCursor		= LoadCursor(NULL, IDC_ARROW);	// Load the default arrow
+	wc.hCursor		= LoadCursor(nullptr, IDC_ARROW);	// Load the default arrow
-	wc.hbrBackground= NULL;							// No Background required for OpenGL
+	wc.hbrBackground= nullptr;						// No Background required for OpenGL
-	wc.lpszMenuName	= NULL;							// No Menu
+	wc.lpszMenuName	= nullptr;						// No Menu
 	wc.lpszClassName= TEXT("OpenGL");		        // Class Name
 
 	if (!RegisterClass(&wc))
 	{
-		MessageBox(NULL, TEXT("Failed to register the window class"), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
+		MessageBox(nullptr, TEXT("Failed to register the window class"), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
 		return FALSE;		//exit and return false
 	}
 
@@ -636,14 +636,14 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
 		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
 		{
 			// If The Mode Fails, Offer Two Options.  Quit Or Run In A Window.
-			if (MessageBox(NULL,TEXT("The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?"),TEXT("NeHe GL"),MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
+			if (MessageBox(nullptr,TEXT("The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?"),TEXT("NeHe GL"),MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
 			{
 				fullscreen = FALSE;		// Select Windowed Mode (Fullscreen = FALSE)
 			}
 			else
 			{
 				//Popup Messagebox: Closing
-				MessageBox(NULL, TEXT("Program will close now."), TEXT("ERROR"), MB_OK|MB_ICONSTOP);
+				MessageBox(nullptr, TEXT("Program will close now."), TEXT("ERROR"), MB_OK|MB_ICONSTOP);
 				return FALSE; //exit, return false
 			}
 		}
@@ -672,10 +672,10 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
 								0, 0,							// Window Position
 								WindowRect.right-WindowRect.left, // Calc adjusted Window Width
 								WindowRect.bottom-WindowRect.top, // Calc adjustes Window Height
-								NULL,							// No Parent Window
+								nullptr,						// No Parent Window
-								NULL,							// No Menu
+								nullptr,						// No Menu
 								g_hInstance,					// Instance
-								NULL )))						// Don't pass anything To WM_CREATE
+								nullptr )))						// Don't pass anything To WM_CREATE
 	{
 		abortGLInit("Window Creation Error.");
 		return FALSE;
@@ -834,7 +834,7 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/,     // The instance
 	// Check the command line for an override file path.
 	int argc;
 	LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
-	if (argv != NULL && argc > 1)
+	if (argv != nullptr && argc > 1)
 	{
 		std::wstring modelpathW(argv[1]);
 		modelpath = UTFConverter(modelpathW).str();
@@ -848,7 +848,7 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/,     // The instance
 
 	logInfo("=============== Post Import ====================");
 
-	if (MessageBox(NULL, TEXT("Would You Like To Run In Fullscreen Mode?"), TEXT("Start Fullscreen?"), MB_YESNO|MB_ICONEXCLAMATION)==IDNO)
+	if (MessageBox(nullptr, TEXT("Would You Like To Run In Fullscreen Mode?"), TEXT("Start Fullscreen?"), MB_YESNO|MB_ICONEXCLAMATION)==IDNO)
 	{
 		fullscreen=FALSE;
 	}
@@ -861,7 +861,7 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/,     // The instance
 
 	while(!done)	// Game Loop
 	{
-		if (PeekMessage(&msg, NULL, 0,0, PM_REMOVE))
+		if (PeekMessage(&msg, nullptr, 0,0, PM_REMOVE))
 		{
 			if (msg.message==WM_QUIT)
 			{

test/CMakeLists.txt

@@ -76,10 +76,12 @@ SET( COMMON
   unit/utProfiler.cpp
   unit/utSharedPPData.cpp
   unit/utStringUtils.cpp
+  unit/Common/uiScene.cpp
   unit/Common/utLineSplitter.cpp
 )
 
 SET( IMPORTERS
+  unit/ImportExport/Assxml/utAssxmlImportExport.cpp
   unit/utLWSImportExport.cpp
   unit/utLWOImportExport.cpp
   unit/utSMDImportExport.cpp
@@ -136,6 +138,9 @@ SET( IMPORTERS
   unit/ImportExport/MDL/utMDLImporter_HL1_ImportSettings.cpp
   unit/ImportExport/MDL/utMDLImporter_HL1_Materials.cpp
   unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp
+  #unit/ImportExport/IRR/utIrrImportExport.cpp
+  unit/ImportExport/RAW/utRAWImportExport.cpp
+  unit/ImportExport/Terragen/utTerragenImportExport.cpp
 )
 
 SET( MATERIAL

test/unit/Common/uiScene.cpp

@@ -0,0 +1,93 @@
+/*
+---------------------------------------------------------------------------
+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.
+---------------------------------------------------------------------------
+*/
+
+#include "UnitTestPCH.h"
+
+#include <assimp/scene.h>
+
+
+using namespace Assimp;
+
+class utScene : public ::testing::Test {
+protected:
+	aiScene *scene;
+
+    void SetUp() override {
+		scene = new aiScene;
+    }
+
+    void TearDown() override {
+		delete scene;
+		scene = nullptr;
+    }
+};
+
+TEST_F(utScene, findNodeTest) {
+	scene->mRootNode = new aiNode();
+	scene->mRootNode->mName.Set("test");
+	aiNode *child = new aiNode;
+	child->mName.Set("child");
+	scene->mRootNode->addChildren(1, &child);
+	aiNode *found = scene->mRootNode->FindNode("child");
+	EXPECT_EQ(child, found);
+}
+
+TEST_F(utScene, sceneHasContentTest) {
+    EXPECT_FALSE(scene->HasAnimations());
+	EXPECT_FALSE(scene->HasMaterials());
+	EXPECT_FALSE(scene->HasMeshes());
+	EXPECT_FALSE(scene->HasCameras());
+	EXPECT_FALSE(scene->HasLights());
+	EXPECT_FALSE(scene->HasTextures());
+}
+
+TEST_F(utScene, getShortFilenameTest) {
+	std::string long_filename1 = "foo_bar/name";
+    const char *name1 = scene->GetShortFilename(long_filename1.c_str());
+	EXPECT_NE(nullptr, name1);
+
+    std::string long_filename2 = "foo_bar\\name";
+    const char *name2 = scene->GetShortFilename(long_filename2.c_str());
+	EXPECT_NE(nullptr, name2);
+}
+
+TEST_F(utScene, getEmbeddedTextureTest) {
+}

test/unit/ImportExport/Assxml/utAssxmlImportExport.cpp

@@ -0,0 +1,76 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2019, 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.
+---------------------------------------------------------------------------
+*/
+
+#include "AbstractImportExportBase.h"
+#include "SceneDiffer.h"
+#include "UnitTestPCH.h"
+
+#include <assimp/postprocess.h>
+#include <assimp/Importer.hpp>
+#include <assimp/Exporter.hpp>
+
+using namespace Assimp;
+
+class utAssxmlImportExport : public AbstractImportExportBase {
+public:
+	bool importerTest() override {
+		return true;
+    }
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+	bool exporterTest() override {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure);
+		EXPECT_NE(scene, nullptr );
+
+        ::Assimp::Exporter exporter;
+		return AI_SUCCESS == exporter.Export(scene, "assxml", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_out.assxml");
+    }
+#endif
+};
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+
+TEST_F(utAssxmlImportExport, exportAssxmlTest) {
+	EXPECT_TRUE(exporterTest());
+}
+
+#endif

test/unit/ImportExport/IRR/utIrrImportExport.cpp

@@ -0,0 +1,66 @@
+/*
+---------------------------------------------------------------------------
+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.
+---------------------------------------------------------------------------
+*/
+#include "AbstractImportExportBase.h"
+#include "UnitTestPCH.h"
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+using namespace Assimp;
+
+class utIrrImportExport : public AbstractImportExportBase {
+public:
+	virtual bool importerTest() {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/IRR/box.irr", aiProcess_ValidateDataStructure);
+		return nullptr != scene;
+	}
+};
+
+TEST_F(utIrrImportExport, importSimpleIrrTest) {
+	EXPECT_TRUE(importerTest());
+}
+
+TEST_F(utIrrImportExport, importSGIrrTest) {
+	Assimp::Importer importer;
+	const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/IRR/dawfInCellar_SameHierarchy.irr", aiProcess_ValidateDataStructure);
+	EXPECT_NE( nullptr,scene);
+}

test/unit/ImportExport/RAW/utRAWImportExport.cpp

@@ -0,0 +1,64 @@
+/*
+---------------------------------------------------------------------------
+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.
+---------------------------------------------------------------------------
+*/
+#include "AbstractImportExportBase.h"
+#include "UnitTestPCH.h"
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+using namespace Assimp;
+
+class utRAWImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/RAW/Wuson.raw", aiProcess_ValidateDataStructure);
+#ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
+        return nullptr != scene;
+#else
+        return nullptr == scene;
+#endif
+    }
+};
+
+TEST_F(utRAWImportExport, importSimpleRAWTest) {
+    EXPECT_TRUE(importerTest());
+}

test/unit/ImportExport/Terragen/utTerragenImportExport.cpp

@@ -0,0 +1,60 @@
+/*
+---------------------------------------------------------------------------
+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.
+---------------------------------------------------------------------------
+*/
+
+#include "AbstractImportExportBase.h"
+#include "UnitTestPCH.h"
+
+#include <assimp/postprocess.h>
+#include <assimp/Importer.hpp>
+
+class utTerragenImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        /*Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/TER/RealisticTerrain.ter", aiProcess_ValidateDataStructure);
+        return nullptr != scene;*/
+        return true;
+    }
+};
+
+TEST_F(utTerragenImportExport, importX3DFromFileTest) {
+    EXPECT_TRUE(importerTest());
+}

test/unit/utM3DImportExport.cpp

@@ -43,6 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "AbstractImportExportBase.h"
 #include "UnitTestPCH.h"
 
+#include <assimp/Importer.hpp>
+#include <assimp/Exporter.hpp>
 #include <assimp/postprocess.h>
 #include <assimp/Importer.hpp>
 
@@ -50,7 +52,7 @@ using namespace Assimp;
 
 class utM3DImportExport : public AbstractImportExportBase {
 public:
-    virtual bool importerTest() {
+	bool importerTest() override  {
         Assimp::Importer importer;
         const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/M3D/cube_normals.m3d", aiProcess_ValidateDataStructure);
 #ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
@@ -59,8 +61,24 @@ public:
         return nullptr == scene;
 #endif // ASSIMP_BUILD_NO_M3D_IMPORTER
     }
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+    bool exporterTest() override {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/M3D/cube_normals.m3d", aiProcess_ValidateDataStructure);
+		Exporter exporter;
+		aiReturn ret = exporter.Export(scene, "m3d", ASSIMP_TEST_MODELS_DIR "/M3D/cube_normals_out.m3d");
+		return ret == AI_SUCCESS;
+    }
+#endif
 };
 
 TEST_F(utM3DImportExport, importM3DFromFileTest) {
     EXPECT_TRUE(importerTest());
 }
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+TEST_F(utM3DImportExport, exportM3DFromFileTest) {
+	EXPECT_TRUE(exporterTest());
+}
+#endif //  ASSIMP_BUILD_NO_EXPORT

tools/assimp_view/Background.cpp

@@ -101,7 +101,7 @@ void CBackgroundPainter::SetColor (D3DCOLOR p_clrNew)
     if (pcTexture)
     {
         pcTexture->Release();
-        pcTexture = NULL;
+        pcTexture = nullptr;
     }
 }
 //-------------------------------------------------------------------------------
@@ -135,7 +135,7 @@ void CBackgroundPainter::SetCubeMapBG (const char* p_szPath)
     if (pcTexture)
     {
         pcTexture->Release();
-        pcTexture = NULL;
+        pcTexture = nullptr;
         if(TEXTURE_CUBE ==eMode)bHad = true;
     }
 
@@ -199,7 +199,7 @@ void CBackgroundPainter::SetTextureBG (const char* p_szPath)
     if (pcTexture)
     {
         pcTexture->Release();
-        pcTexture = NULL;
+        pcTexture = nullptr;
     }
 
     eMode = TEXTURE_2D;
@@ -223,12 +223,12 @@ void CBackgroundPainter::OnPreRender()
         // the color buffer )
         if (g_sOptions.eDrawMode == RenderOptions::WIREFRAME)
         {
-            g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET,
+            g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET,
                 D3DCOLOR_ARGB(0xff,100,100,100),1.0f,0);
         }
         else
         {
-            g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER,0,1.0f,0);
+            g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER,0,1.0f,0);
         }
 
         if (TEXTURE_2D == eMode)
@@ -293,7 +293,7 @@ void CBackgroundPainter::OnPreRender()
         return;
     }
     // clear both the render target and the z-buffer
-    g_piDevice->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
+    g_piDevice->Clear(0,nullptr,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
         clrColor,1.0f,0);
 }
 //-------------------------------------------------------------------------------
@@ -342,12 +342,12 @@ void CBackgroundPainter::ReleaseNativeResource()
     if ( piSkyBoxEffect)
     {
         piSkyBoxEffect->Release();
-        piSkyBoxEffect = NULL;
+        piSkyBoxEffect = nullptr;
     }
     if (pcTexture)
     {
         pcTexture->Release();
-        pcTexture = NULL;
+        pcTexture = nullptr;
     }
 }
 //-------------------------------------------------------------------------------
@@ -377,8 +377,8 @@ void CBackgroundPainter::RecreateNativeResource()
             D3DX_DEFAULT,
             D3DX_DEFAULT,
             0,
-            NULL,
+            nullptr,
-            NULL,
+            nullptr,
             (IDirect3DCubeTexture9**)&pcTexture)))
         {
             const char* szEnd = strrchr(szPath.c_str(),'\\');
@@ -411,8 +411,8 @@ void CBackgroundPainter::RecreateNativeResource()
             D3DX_DEFAULT,
             D3DX_DEFAULT,
             0,
-            NULL,
+            nullptr,
-            NULL,
+            nullptr,
             (IDirect3DTexture9**)&pcTexture)))
         {
             const char* szEnd = strrchr(szPath.c_str(),'\\');
@@ -433,15 +433,15 @@ void CBackgroundPainter::RecreateNativeResource()
     }
     if (!piSkyBoxEffect)
     {
-        ID3DXBuffer* piBuffer = NULL;
+        ID3DXBuffer* piBuffer = nullptr;
         if(FAILED( D3DXCreateEffect(
             g_piDevice,
             g_szSkyboxShader.c_str(),
             (UINT)g_szSkyboxShader.length(),
-            NULL,
+            nullptr,
-            NULL,
+            nullptr,
             AI_SHADER_COMPILE_FLAGS,
-            NULL,
+            nullptr,
             &piSkyBoxEffect,&piBuffer)))
         {
             // failed to compile the shader

tools/assimp_view/Display.cpp

@@ -158,8 +158,8 @@ int CDisplay::AddNodeToDisplayList(
     aiNode* pcNode,
     HTREEITEM hRoot)
 {
-    ai_assert(NULL != pcNode);
+    ai_assert(nullptr != pcNode);
-    ai_assert(NULL != hRoot);
+    ai_assert(nullptr != hRoot);
 
     char chTemp[MAXLEN];
 
@@ -269,10 +269,10 @@ int CDisplay::AddMeshToDisplayList(unsigned int iIndex, HTREEITEM hRoot)
 // Replace the currently selected texture by another one
 int CDisplay::ReplaceCurrentTexture(const char* szPath)
 {
-    ai_assert(NULL != szPath);
+    ai_assert(nullptr != szPath);
 
     // well ... try to load it
-    IDirect3DTexture9* piTexture = NULL;
+    IDirect3DTexture9* piTexture = nullptr;
     aiString szString;
     strcpy(szString.data,szPath);
     szString.length = static_cast<ai_uint32>(strlen(szPath));
@@ -301,8 +301,8 @@ int CDisplay::ReplaceCurrentTexture(const char* szPath)
             continue;
 
         AssetHelper::MeshHelper* pcMesh = g_pcAsset->apcMeshes[i];
-        IDirect3DTexture9** tex = NULL;
+        IDirect3DTexture9** tex = nullptr;
-        const char* tex_string  = NULL;
+        const char* tex_string  = nullptr;
 
         switch (this->m_pcCurrentTexture->iType)
         {
@@ -378,7 +378,7 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType,
     aiTextureOp eTextureOp      /*= aiTextureOp_Multiply*/,
     unsigned int iMesh      /*= 0*/)
 {
-    ai_assert(NULL != szPath);
+    ai_assert(nullptr != szPath);
 
     char chTemp[512];
     char chTempEmb[256];
@@ -436,15 +436,15 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType,
         szType = "Lightmap";
         break;
     case aiTextureType_DISPLACEMENT:
-        piTexture = NULL;
+        piTexture = nullptr;
         szType = "Displacement";
         break;
     case aiTextureType_REFLECTION:
-        piTexture = NULL;
+        piTexture = nullptr;
         szType = "Reflection";
         break;
     case aiTextureType_UNKNOWN:
-        piTexture = NULL;
+        piTexture = nullptr;
         szType = "Unknown";
         break;
     default: // opacity + opacity | mask
@@ -521,7 +521,7 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType,
 int CDisplay::AddMaterialToDisplayList(HTREEITEM hRoot,
     unsigned int iIndex)
 {
-    ai_assert(NULL != hRoot);
+    ai_assert(nullptr != hRoot);
 
     aiMaterial* pcMat = g_pcAsset->pcScene->mMaterials[iIndex];
 
@@ -583,7 +583,7 @@ int CDisplay::AddMaterialToDisplayList(HTREEITEM hRoot,
         while (true)
         {
             if (AI_SUCCESS != aiGetMaterialTexture(pcMat,(aiTextureType)i,iNum,
-                &szPath,NULL, &iUV,&fBlend,&eOp))
+                &szPath,nullptr, &iUV,&fBlend,&eOp))
             {
                 break;
             }
@@ -658,23 +658,23 @@ int CDisplay::LoadImageList(void)
 
         // Load the bitmaps and add them to the image lists.
         HBITMAP hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BFX));
-        m_aiImageList[AI_VIEW_IMGLIST_MATERIAL] = ImageList_Add(hIml, hBmp, NULL);
+        m_aiImageList[AI_VIEW_IMGLIST_MATERIAL] = ImageList_Add(hIml, hBmp, nullptr);
         DeleteObject(hBmp);
 
         hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BNODE));
-        m_aiImageList[AI_VIEW_IMGLIST_NODE] = ImageList_Add(hIml, hBmp, NULL);
+        m_aiImageList[AI_VIEW_IMGLIST_NODE] = ImageList_Add(hIml, hBmp, nullptr);
         DeleteObject(hBmp);
 
         hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BTX));
-        m_aiImageList[AI_VIEW_IMGLIST_TEXTURE] = ImageList_Add(hIml, hBmp, NULL);
+        m_aiImageList[AI_VIEW_IMGLIST_TEXTURE] = ImageList_Add(hIml, hBmp, nullptr);
         DeleteObject(hBmp);
 
         hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BTXI));
-        m_aiImageList[AI_VIEW_IMGLIST_TEXTURE_INVALID] = ImageList_Add(hIml, hBmp, NULL);
+        m_aiImageList[AI_VIEW_IMGLIST_TEXTURE_INVALID] = ImageList_Add(hIml, hBmp, nullptr);
         DeleteObject(hBmp);
 
         hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BROOT));
-        m_aiImageList[AI_VIEW_IMGLIST_MODEL] = ImageList_Add(hIml, hBmp, NULL);
+        m_aiImageList[AI_VIEW_IMGLIST_MODEL] = ImageList_Add(hIml, hBmp, nullptr);
         DeleteObject(hBmp);
 
         // Associate the image list with the tree.
@@ -778,7 +778,7 @@ int CDisplay::OnRender()
 
     // present the back-buffer
     g_piDevice->EndScene();
-    g_piDevice->Present(NULL,NULL,NULL,NULL);
+    g_piDevice->Present(nullptr,nullptr,nullptr,nullptr);
 
     // don't remove this, problems on some older machines (AMD timing bug)
     Sleep(10);
@@ -788,9 +788,9 @@ int CDisplay::OnRender()
 // Update UI
 void UpdateColorFieldsInUI()
 {
-    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),NULL,TRUE);
+    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),nullptr,TRUE);
-    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE);
+    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE);
-    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,TRUE);
+    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),nullptr,TRUE);
 
     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR1));
     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR2));
@@ -859,7 +859,7 @@ int CDisplay::Reset(void)
     m_asNodes.clear();
     m_asMeshes.clear();
 
-    m_hRoot = NULL;
+    m_hRoot = nullptr;
 
     return OnSetupNormalView();
 }
@@ -896,9 +896,9 @@ int CDisplay::OnSetupNormalView()
     SetViewMode(VIEWMODE_FULL);
 
     // for debugging
-    m_pcCurrentMaterial = NULL;
+    m_pcCurrentMaterial = nullptr;
-    m_pcCurrentTexture = NULL;
+    m_pcCurrentTexture = nullptr;
-    m_pcCurrentNode = NULL;
+    m_pcCurrentNode = nullptr;
 
     // redraw the color fields in the UI --- their purpose has possibly changed
     UpdateColorFieldsInUI();
@@ -908,7 +908,7 @@ int CDisplay::OnSetupNormalView()
 //-------------------------------------------------------------------------------
 int CDisplay::OnSetupNodeView(NodeInfo* pcNew)
 {
-    ai_assert(NULL != pcNew);
+    ai_assert(nullptr != pcNew);
 
     if (m_pcCurrentNode == pcNew)return 2;
 
@@ -955,7 +955,7 @@ int CDisplay::OnSetupNodeView(NodeInfo* pcNew)
 //-------------------------------------------------------------------------------
 int CDisplay::OnSetupMaterialView(MaterialInfo* pcNew)
 {
-    ai_assert(NULL != pcNew);
+    ai_assert(nullptr != pcNew);
 
     if (m_pcCurrentMaterial == pcNew)return 2;
 
@@ -973,7 +973,7 @@ int CDisplay::OnSetupMaterialView(MaterialInfo* pcNew)
 //-------------------------------------------------------------------------------
 int CDisplay::OnSetupTextureView(TextureInfo* pcNew)
 {
-    ai_assert(NULL != pcNew);
+    ai_assert(nullptr != pcNew);
 
     if (this->m_pcCurrentTexture == pcNew)return 2;
 
@@ -1099,7 +1099,7 @@ int CDisplay::OnSetup(HTREEITEM p_hTreeItem)
         MaterialInfo* pcNew3;
     };
 
-    pcNew = NULL;
+    pcNew = nullptr;
     for (std::vector<TextureInfo>::iterator i =  m_asTextures.begin();i != m_asTextures.end();++i){
         if (p_hTreeItem == (*i).hTreeItem)  {
             pcNew = &(*i);
@@ -1136,12 +1136,12 @@ int CDisplay::OnSetup(HTREEITEM p_hTreeItem)
 //-------------------------------------------------------------------------------
 int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem)
 {
-    ai_assert(NULL != hItem);
+    ai_assert(nullptr != hItem);
 
-    HMENU hDisplay = NULL;
+    HMENU hDisplay = nullptr;
 
     // search in our list for the item
-    TextureInfo* pcNew = NULL;
+    TextureInfo* pcNew = nullptr;
     for (std::vector<TextureInfo>::iterator
         i =  m_asTextures.begin();
         i != m_asTextures.end();++i)
@@ -1158,7 +1158,7 @@ int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem)
     }
 
     // search in the material list for the item
-    MaterialInfo* pcNew2 = NULL;
+    MaterialInfo* pcNew2 = nullptr;
     for (std::vector<MaterialInfo>::iterator
         i =  m_asMaterials.begin();
         i != m_asMaterials.end();++i)
@@ -1173,7 +1173,7 @@ int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem)
         HMENU hMenu = LoadMenu(g_hInstance,MAKEINTRESOURCE(IDR_MATPOPUP));
         hDisplay = GetSubMenu(hMenu,0);
     }
-    if (NULL != hDisplay)
+    if (nullptr != hDisplay)
     {
         // select this entry (this should all OnSetup())
         TreeView_Select(GetDlgItem(g_hDlg,IDC_TREE1),hItem,TVGN_CARET);
@@ -1185,7 +1185,7 @@ int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem)
         POINT sPoint;
         GetCursorPos(&sPoint);
         TrackPopupMenu(hDisplay, TPM_LEFTALIGN, sPoint.x, sPoint.y, 0,
-            g_hDlg,NULL);
+            g_hDlg,nullptr);
     }
     return 1;
 }
@@ -1260,8 +1260,8 @@ int CDisplay::HandleTreeViewPopup(WPARAM wParam,LPARAM lParam)
             clamp<unsigned char>(clrOld.g * 255.0f),
             clamp<unsigned char>(clrOld.b * 255.0f));
         clr.lpCustColors = g_aclCustomColors;
-        clr.lpfnHook = NULL;
+        clr.lpfnHook = nullptr;
-        clr.lpTemplateName = NULL;
+        clr.lpTemplateName = nullptr;
         clr.lCustData = 0;
 
         ChooseColor(&clr);
@@ -1318,7 +1318,7 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/)
     case ID_HEY_REPLACE:
         {
         // get a path to a new texture
-        if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ReplaceTextureSrc",NULL,NULL,
+        if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ReplaceTextureSrc",nullptr,nullptr,
             (BYTE*)szFileName,&dwTemp))
         {
             // Key was not found. Use C:
@@ -1335,13 +1335,13 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/)
         }
         OPENFILENAME sFilename1 = {
             sizeof(OPENFILENAME),
-            g_hDlg,GetModuleHandle(NULL),
+            g_hDlg,GetModuleHandle(nullptr),
             "Textures\0*.png;*.dds;*.tga;*.bmp;*.tif;*.ppm;*.ppx;*.jpg;*.jpeg;*.exr\0*.*\0",
-            NULL, 0, 1,
+            nullptr, 0, 1,
-            szFileName, MAX_PATH, NULL, 0, NULL,
+            szFileName, MAX_PATH, nullptr, 0, nullptr,
             "Replace this texture",
             OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-            0, 1, ".jpg", 0, NULL, NULL
+            0, 1, ".jpg", 0, nullptr, nullptr
         };
         if(GetOpenFileName(&sFilename1) == 0) return 0;
 
@@ -1353,7 +1353,7 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/)
 
     case ID_HEY_EXPORT:
         {
-        if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureExportDest",NULL,NULL,
+        if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureExportDest",nullptr,nullptr,
             (BYTE*)szFileName,&dwTemp))
         {
             // Key was not found. Use C:
@@ -1370,12 +1370,12 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/)
         }
         OPENFILENAME sFilename1 = {
             sizeof(OPENFILENAME),
-            g_hDlg,GetModuleHandle(NULL),
+            g_hDlg,GetModuleHandle(nullptr),
-            "Textures\0*.png;*.dds;*.bmp;*.tif;*.pfm;*.jpg;*.jpeg;*.hdr\0*.*\0", NULL, 0, 1,
+            "Textures\0*.png;*.dds;*.bmp;*.tif;*.pfm;*.jpg;*.jpeg;*.hdr\0*.*\0", nullptr, 0, 1,
-            szFileName, MAX_PATH, NULL, 0, NULL,
+            szFileName, MAX_PATH, nullptr, 0, nullptr,
             "Export texture to file",
             OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-            0, 1, ".png", 0, NULL, NULL
+            0, 1, ".png", 0, nullptr, nullptr
         };
         if(GetSaveFileName(&sFilename1) == 0) return 0;
 
@@ -1397,9 +1397,9 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/)
         }
 
         // get a pointer to the first surface of the current texture
-        IDirect3DSurface9* pi = NULL;
+        IDirect3DSurface9* pi = nullptr;
         (*this->m_pcCurrentTexture->piTexture)->GetSurfaceLevel(0,&pi);
-        if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,eFormat,pi,NULL,NULL)))
+        if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,eFormat,pi,nullptr,nullptr)))
         {
             CLogDisplay::Instance().AddEntry("[ERROR] Unable to export texture",
                 D3DCOLOR_ARGB(0xFF,0xFF,0,0));
@@ -1495,7 +1495,7 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/)
 // Setup stereo view
 int CDisplay::SetupStereoView()
 {
-    if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode)
+    if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode)
     {
         // enable the RED, GREEN and ALPHA channels
         g_piDevice->SetRenderState(D3DRS_COLORWRITEENABLE,
@@ -1513,7 +1513,7 @@ int CDisplay::SetupStereoView()
 int CDisplay::RenderStereoView(const aiMatrix4x4& m)
 {
     // and rerender the scene
-    if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode)
+    if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode)
     {
         // enable the BLUE, GREEN and ALPHA channels
         g_piDevice->SetRenderState(D3DRS_COLORWRITEENABLE,
@@ -1522,7 +1522,7 @@ int CDisplay::RenderStereoView(const aiMatrix4x4& m)
             D3DCOLORWRITEENABLE_BLUE);
 
         // clear the z-buffer
-        g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER,0,1.0f,0);
+        g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER,0,1.0f,0);
 
         // move the camera a little bit to the right
         g_sCamera.vPos += g_sCamera.vRight * 0.06f;
@@ -1751,7 +1751,7 @@ int CDisplay::RenderFullScene()
 
     // draw all opaque objects in the scene
     aiMatrix4x4 m;
-    if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode)
+    if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode)
     {
         HandleInput();
         m =  g_mWorld * g_mWorldRotate;
@@ -1766,7 +1766,7 @@ int CDisplay::RenderFullScene()
     CBackgroundPainter::Instance().OnPostRender();
 
     // draw all non-opaque objects in the scene
-    if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode)
+    if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode)
     {
         // disable the z-buffer
         if (!g_sOptions.bNoAlphaBlending) {
@@ -1784,7 +1784,7 @@ int CDisplay::RenderFullScene()
         RenderStereoView(m);
 
     // render the skeleton if necessary
-    if (g_sOptions.bSkeleton && NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode) {
+    if (g_sOptions.bSkeleton && nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode) {
         // disable the z-buffer
         g_piDevice->SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
 
@@ -2098,14 +2098,14 @@ int CDisplay::RenderPatternBG()
         {
             // seems we have not yet compiled this shader.
             // and NOW is the best time to do that ...
-            ID3DXBuffer* piBuffer = NULL;
+            ID3DXBuffer* piBuffer = nullptr;
             if(FAILED( D3DXCreateEffect(g_piDevice,
                 g_szCheckerBackgroundShader.c_str(),
                 (UINT)g_szCheckerBackgroundShader.length(),
-                NULL,
+                nullptr,
-                NULL,
+                nullptr,
                 D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,
-                NULL,
+                nullptr,
                 &g_piPatternEffect,&piBuffer)))
             {
                 if( piBuffer)
@@ -2118,7 +2118,7 @@ int CDisplay::RenderPatternBG()
             if( piBuffer)
             {
                 piBuffer->Release();
-                piBuffer = NULL;
+                piBuffer = nullptr;
             }
         }
         else
@@ -2126,14 +2126,14 @@ int CDisplay::RenderPatternBG()
             // clear the color buffer in magenta
             // (hopefully this is ugly enough that every ps_2_0 cards owner
             //  runs to the next shop to buy himself a new card ...)
-            g_piDevice->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
+            g_piDevice->Clear(0,nullptr,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                 D3DCOLOR_ARGB(0xFF,0xFF,0,0xFF), 1.0f,0 );
             return 1;
         }
     }
 
     // clear the depth buffer only
-    g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER,
+    g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER,
         D3DCOLOR_ARGB(0xFF,0xFF,0,0xFF), 1.0f,0 );
 
     // setup the colors to be used ...

tools/assimp_view/HelpDialog.cpp

@@ -53,8 +53,8 @@ INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM ) {
         case WM_INITDIALOG:
         {
             // load the help file ...
-            HRSRC res = FindResource(NULL,MAKEINTRESOURCE(IDR_TEXT1),"TEXT");
+            HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_TEXT1),"TEXT");
-            HGLOBAL hg = LoadResource(NULL,res);
+            HGLOBAL hg = LoadResource(nullptr,res);
             void* pData = LockResource(hg);
 
             SETTEXTEX sInfo;

tools/assimp_view/LogDisplay.cpp

@@ -117,29 +117,29 @@ void CLogDisplay::OnRender() {
         sCopy.top       = sWndRect.top+1;
         sCopy.bottom    = sWndRect.bottom+1;
         sCopy.right     = sWndRect.right+1;
-        this->piFont->DrawText(NULL,szText ,
+        this->piFont->DrawText(nullptr,szText ,
             -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0));
         sCopy.left      = sWndRect.left+1;
         sCopy.top       = sWndRect.top+1;
         sCopy.bottom    = sWndRect.bottom-1;
         sCopy.right     = sWndRect.right-1;
-        this->piFont->DrawText(NULL,szText ,
+        this->piFont->DrawText(nullptr,szText ,
             -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0));
         sCopy.left      = sWndRect.left-1;
         sCopy.top       = sWndRect.top-1;
         sCopy.bottom    = sWndRect.bottom+1;
         sCopy.right     = sWndRect.right+1;
-        this->piFont->DrawText(NULL,szText ,
+        this->piFont->DrawText(nullptr,szText ,
             -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0));
         sCopy.left      = sWndRect.left-1;
         sCopy.top       = sWndRect.top-1;
         sCopy.bottom    = sWndRect.bottom-1;
         sCopy.right     = sWndRect.right-1;
-        this->piFont->DrawText(NULL,szText ,
+        this->piFont->DrawText(nullptr,szText ,
             -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0));
 
         // text
-        this->piFont->DrawText(NULL,szText ,
+        this->piFont->DrawText(nullptr,szText ,
             -1,&sWndRect,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0xFF));
     }
 
@@ -176,7 +176,7 @@ void CLogDisplay::OnRender() {
             sCopy.top       = sRect.top+1;
             sCopy.bottom    = sRect.bottom+1;
             sCopy.right     = sRect.right+1;
-            this->piFont->DrawText(NULL,szText,
+            this->piFont->DrawText(nullptr,szText,
                 -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB(
                 (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0));
 
@@ -184,7 +184,7 @@ void CLogDisplay::OnRender() {
             sCopy.top       = sRect.top-1;
             sCopy.bottom    = sRect.bottom-1;
             sCopy.right     = sRect.right-1;
-            this->piFont->DrawText(NULL,szText,
+            this->piFont->DrawText(nullptr,szText,
                 -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB(
                 (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0));
 
@@ -192,7 +192,7 @@ void CLogDisplay::OnRender() {
             sCopy.top       = sRect.top-1;
             sCopy.bottom    = sRect.bottom+1;
             sCopy.right     = sRect.right+1;
-            this->piFont->DrawText(NULL,szText,
+            this->piFont->DrawText(nullptr,szText,
                 -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB(
                 (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0));
 
@@ -200,12 +200,12 @@ void CLogDisplay::OnRender() {
             sCopy.top       = sRect.top+1;
             sCopy.bottom    = sRect.bottom-1;
             sCopy.right     = sRect.right-1;
-            this->piFont->DrawText(NULL,szText,
+            this->piFont->DrawText(nullptr,szText,
                 -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB(
                 (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0));
 
             // draw the text itself
-            int iPX = this->piFont->DrawText(NULL,szText,
+            int iPX = this->piFont->DrawText(nullptr,szText,
                 -1,&sRect,DT_RIGHT | DT_TOP,clrColor);
 
             sRect.top += iPX;

tools/assimp_view/LogWindow.cpp

@@ -86,7 +86,7 @@ INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg,
             int x = LOWORD(lParam);
             int y = HIWORD(lParam);
 
-            SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),NULL,0,0,
+            SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),nullptr,0,0,
                 x-10,y-12,SWP_NOMOVE|SWP_NOZORDER);
 
             return TRUE;
@@ -103,7 +103,7 @@ INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg,
 //-------------------------------------------------------------------------------
 void CLogWindow::Init () {
     this->hwnd = ::CreateDialog(g_hInstance,MAKEINTRESOURCE(IDD_LOGVIEW),
-        NULL,&LogDialogProc);
+        nullptr,&LogDialogProc);
 
     if (!this->hwnd) {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to create logger window",
@@ -156,7 +156,7 @@ void CLogWindow::Save() {
     char szFileName[MAX_PATH];
 
     DWORD dwTemp = MAX_PATH;
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LogDestination",NULL,NULL,(BYTE*)szFileName,&dwTemp)) {
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LogDestination",nullptr,nullptr,(BYTE*)szFileName,&dwTemp)) {
         // Key was not found. Use C:
         strcpy(szFileName,"");
     } else {
@@ -169,12 +169,12 @@ void CLogWindow::Save() {
     }
     OPENFILENAME sFilename1 = {
         sizeof(OPENFILENAME),
-        g_hDlg,GetModuleHandle(NULL),
+        g_hDlg,GetModuleHandle(nullptr),
-        "Log files\0*.txt", NULL, 0, 1,
+        "Log files\0*.txt", nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        szFileName, MAX_PATH, nullptr, 0, nullptr,
         "Save log to file",
         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-        0, 1, ".txt", 0, NULL, NULL
+        0, 1, ".txt", 0, nullptr, nullptr
     };
     if(GetSaveFileName(&sFilename1) == 0) return;
 

tools/assimp_view/Material.cpp

@@ -210,15 +210,15 @@ int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut)
         D3DFMT_A8R8G8B8,
         D3DPOOL_MANAGED,
         p_ppiOut,
-        NULL)))
+        nullptr)))
     {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to create default texture",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
 
-        *p_ppiOut = NULL;
+        *p_ppiOut = nullptr;
         return 0;
     }
-    D3DXFillTexture(*p_ppiOut,&FillFunc,NULL);
+    D3DXFillTexture(*p_ppiOut,&FillFunc,nullptr);
     sDefaultTexture = *p_ppiOut;
     sDefaultTexture->AddRef();
 
@@ -316,7 +316,7 @@ bool CMaterialManager::TryLongerPath(char* szTemp,aiString* p_szString)
 //-------------------------------------------------------------------------------
 int CMaterialManager::FindValidPath(aiString* p_szString)
 {
-    ai_assert(NULL != p_szString);
+    ai_assert(nullptr != p_szString);
     aiString pcpy = *p_szString;
     if ('*' ==  p_szString->data[0])    {
         // '*' as first character indicates an embedded file
@@ -402,23 +402,22 @@ int CMaterialManager::FindValidPath(aiString* p_szString)
         }
         fclose(pFile);
 
-        // copy the result string back to the aiString
+        // copy the result string back to the aiStr
-        const size_t iLen = strlen(szTemp);
+        const size_t len = strlen(szTemp);
-        size_t iLen2 = iLen+1;
+        size_t len2 = len+1;
-        iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
+        len2 = len2 > MAXLEN ? MAXLEN : len2;
-        memcpy(p_szString->data,szTemp,iLen2);
+        memcpy(p_szString->data, szTemp, len2);
-        p_szString->length = static_cast<ai_uint32>(iLen);
+        p_szString->length = static_cast<ai_uint32>(len);
-
     }
     return 1;
 }
 //-------------------------------------------------------------------------------
 int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
 {
-    ai_assert(NULL != p_ppiOut);
+    ai_assert(nullptr != p_ppiOut);
-    ai_assert(NULL != szPath);
+    ai_assert(nullptr != szPath);
 
-    *p_ppiOut = NULL;
+    *p_ppiOut = nullptr;
 
     const std::string s = szPath->data;
     TextureCache::iterator ff;
@@ -453,7 +452,7 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
                     D3DX_DEFAULT,
                     0,
                     &info,
-                    NULL,
+                    nullptr,
                     p_ppiOut)))
                 {
                     std::string sz = "[ERROR] Unable to load embedded texture (#1): ";
@@ -470,7 +469,7 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
                 if(FAILED(g_piDevice->CreateTexture(
                     g_pcAsset->pcScene->mTextures[iIndex]->mWidth,
                     g_pcAsset->pcScene->mTextures[iIndex]->mHeight,
-                    0,D3DUSAGE_AUTOGENMIPMAP,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,p_ppiOut,NULL)))
+                    0,D3DUSAGE_AUTOGENMIPMAP,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,p_ppiOut,nullptr)))
                 {
                     std::string sz = "[ERROR] Unable to load embedded texture (#2): ";
                     sz.append(szPath->data);
@@ -482,7 +481,7 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
 
                 // now copy the data to it ... (assume non pow2 to be supported)
                 D3DLOCKED_RECT sLock;
-                (*p_ppiOut)->LockRect(0,&sLock,NULL,0);
+                (*p_ppiOut)->LockRect(0,&sLock,nullptr,0);
 
                 const aiTexel* pcData = g_pcAsset->pcScene->mTextures[iIndex]->pcData;
 
@@ -524,8 +523,8 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
         D3DX_DEFAULT,
         D3DX_DEFAULT,
         0,
-        NULL,
+        nullptr,
-        NULL,
+        nullptr,
         p_ppiOut)))
     {
         // error ... use the default texture instead
@@ -550,44 +549,44 @@ void CMaterialManager::DeleteMaterial(AssetHelper::MeshHelper* pcIn)
     if (pcIn->piDiffuseTexture)
     {
         pcIn->piDiffuseTexture->Release();
-        pcIn->piDiffuseTexture = NULL;
+        pcIn->piDiffuseTexture = nullptr;
     }
     if (pcIn->piSpecularTexture)
     {
         pcIn->piSpecularTexture->Release();
-        pcIn->piSpecularTexture = NULL;
+        pcIn->piSpecularTexture = nullptr;
     }
     if (pcIn->piEmissiveTexture)
     {
         pcIn->piEmissiveTexture->Release();
-        pcIn->piEmissiveTexture = NULL;
+        pcIn->piEmissiveTexture = nullptr;
     }
     if (pcIn->piAmbientTexture)
     {
         pcIn->piAmbientTexture->Release();
-        pcIn->piAmbientTexture = NULL;
+        pcIn->piAmbientTexture = nullptr;
     }
     if (pcIn->piOpacityTexture)
     {
         pcIn->piOpacityTexture->Release();
-        pcIn->piOpacityTexture = NULL;
+        pcIn->piOpacityTexture = nullptr;
     }
     if (pcIn->piNormalTexture)
     {
         pcIn->piNormalTexture->Release();
-        pcIn->piNormalTexture = NULL;
+        pcIn->piNormalTexture = nullptr;
     }
     if (pcIn->piShininessTexture)
     {
         pcIn->piShininessTexture->Release();
-        pcIn->piShininessTexture = NULL;
+        pcIn->piShininessTexture = nullptr;
     }
     if (pcIn->piLightmapTexture)
     {
         pcIn->piLightmapTexture->Release();
-        pcIn->piLightmapTexture = NULL;
+        pcIn->piLightmapTexture = nullptr;
     }
-    pcIn->piEffect = NULL;
+    pcIn->piEffect = nullptr;
 }
 //-------------------------------------------------------------------------------
 void CMaterialManager::HMtoNMIfNecessary(
@@ -595,8 +594,8 @@ void CMaterialManager::HMtoNMIfNecessary(
     IDirect3DTexture9** piTextureOut,
     bool bWasOriginallyHM)
 {
-    ai_assert(NULL != piTexture);
+    ai_assert(nullptr != piTexture);
-    ai_assert(NULL != piTextureOut);
+    ai_assert(nullptr != piTextureOut);
 
     bool bMustConvert = false;
     uintptr_t iElement = 3;
@@ -617,7 +616,7 @@ void CMaterialManager::HMtoNMIfNecessary(
     D3DLOCKED_RECT sRect;
     D3DSURFACE_DESC sDesc;
     piTexture->GetLevelDesc(0,&sDesc);
-    if (FAILED(piTexture->LockRect(0,&sRect,NULL,D3DLOCK_READONLY)))
+    if (FAILED(piTexture->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY)))
     {
         return;
     }
@@ -749,7 +748,7 @@ void CMaterialManager::HMtoNMIfNecessary(
             piTexture->GetLevelCount(),
             sDesc2.Usage,
             sDesc2.Format,
-            sDesc2.Pool, &piTempTexture, NULL)))
+            sDesc2.Pool, &piTempTexture, nullptr)))
         {
             CLogDisplay::Instance().AddEntry(
                 "[ERROR] Unable to create normal map texture",
@@ -764,7 +763,7 @@ void CMaterialManager::HMtoNMIfNecessary(
         else /*if (0 == iElement)*/dwFlags = D3DX_CHANNEL_BLUE;
 
         if(FAILED(D3DXComputeNormalMap(piTempTexture,
-            piTexture,NULL,0,dwFlags,1.0f)))
+            piTexture,nullptr,0,dwFlags,1.0f)))
         {
             CLogDisplay::Instance().AddEntry(
                 "[ERROR] Unable to compute normal map from height map",
@@ -780,12 +779,12 @@ void CMaterialManager::HMtoNMIfNecessary(
 //-------------------------------------------------------------------------------
 bool CMaterialManager::HasAlphaPixels(IDirect3DTexture9* piTexture)
 {
-    ai_assert(NULL != piTexture);
+    ai_assert(nullptr != piTexture);
 
     D3DLOCKED_RECT sRect;
     D3DSURFACE_DESC sDesc;
     piTexture->GetLevelDesc(0,&sDesc);
-    if (FAILED(piTexture->LockRect(0,&sRect,NULL,D3DLOCK_READONLY)))
+    if (FAILED(piTexture->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY)))
     {
         return false;
     }
@@ -823,8 +822,8 @@ bool CMaterialManager::HasAlphaPixels(IDirect3DTexture9* piTexture)
 int CMaterialManager::CreateMaterial(
     AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource)
 {
-    ai_assert(NULL != pcMesh);
+    ai_assert(nullptr != pcMesh);
-    ai_assert(NULL != pcSource);
+    ai_assert(nullptr != pcSource);
 
     ID3DXBuffer* piBuffer;
 
@@ -1060,29 +1059,29 @@ int CMaterialManager::CreateMaterial(
         }
         AssetHelper::MeshHelper* pc = g_pcAsset->apcMeshes[i];
 
-        if  ((pcMesh->piDiffuseTexture != NULL ? true : false) !=
+        if  ((pcMesh->piDiffuseTexture != nullptr ? true : false) !=
-            (pc->piDiffuseTexture != NULL ? true : false))
+            (pc->piDiffuseTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piSpecularTexture != NULL ? true : false) !=
+        if  ((pcMesh->piSpecularTexture != nullptr ? true : false) !=
-            (pc->piSpecularTexture != NULL ? true : false))
+            (pc->piSpecularTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piAmbientTexture != NULL ? true : false) !=
+        if  ((pcMesh->piAmbientTexture != nullptr ? true : false) !=
-            (pc->piAmbientTexture != NULL ? true : false))
+            (pc->piAmbientTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piEmissiveTexture != NULL ? true : false) !=
+        if  ((pcMesh->piEmissiveTexture != nullptr ? true : false) !=
-            (pc->piEmissiveTexture != NULL ? true : false))
+            (pc->piEmissiveTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piNormalTexture != NULL ? true : false) !=
+        if  ((pcMesh->piNormalTexture != nullptr ? true : false) !=
-            (pc->piNormalTexture != NULL ? true : false))
+            (pc->piNormalTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piOpacityTexture != NULL ? true : false) !=
+        if  ((pcMesh->piOpacityTexture != nullptr ? true : false) !=
-            (pc->piOpacityTexture != NULL ? true : false))
+            (pc->piOpacityTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piShininessTexture != NULL ? true : false) !=
+        if  ((pcMesh->piShininessTexture != nullptr ? true : false) !=
-            (pc->piShininessTexture != NULL ? true : false))
+            (pc->piShininessTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piLightmapTexture != NULL ? true : false) !=
+        if  ((pcMesh->piLightmapTexture != nullptr ? true : false) !=
-            (pc->piLightmapTexture != NULL ? true : false))
+            (pc->piLightmapTexture != nullptr ? true : false))
             continue;
         if ((pcMesh->eShadingMode != aiShadingMode_Gouraud ? true : false) !=
             (pc->eShadingMode != aiShadingMode_Gouraud ? true : false))
@@ -1239,13 +1238,13 @@ int CMaterialManager::CreateMaterial(
         sMacro[iCurrent].Definition = "1";
         ++iCurrent;
     }
-    sMacro[iCurrent].Name = NULL;
+    sMacro[iCurrent].Name = nullptr;
-    sMacro[iCurrent].Definition = NULL;
+    sMacro[iCurrent].Definition = nullptr;
 
     // compile the shader
     if(FAILED( D3DXCreateEffect(g_piDevice,
         g_szMaterialShader.c_str(),(UINT)g_szMaterialShader.length(),
-        (const D3DXMACRO*)sMacro,NULL,0,NULL,&pcMesh->piEffect,&piBuffer)))
+        (const D3DXMACRO*)sMacro,nullptr,0,nullptr,&pcMesh->piEffect,&piBuffer)))
     {
         // failed to compile the shader
         if( piBuffer)
@@ -1333,7 +1332,7 @@ int CMaterialManager::SetupMaterial (
     const aiMatrix4x4& pcCam,
     const aiVector3D& vPos)
 {
-    ai_assert(NULL != pcMesh);
+    ai_assert(nullptr != pcMesh);
     if (!pcMesh->piEffect)return 0;
 
     ID3DXEffect* piEnd = pcMesh->piEffect;
@@ -1476,7 +1475,7 @@ int CMaterialManager::SetupMaterial (
 //-------------------------------------------------------------------------------
 int CMaterialManager::EndMaterial (AssetHelper::MeshHelper* pcMesh)
 {
-    ai_assert(NULL != pcMesh);
+    ai_assert(nullptr != pcMesh);
     if (!pcMesh->piEffect)return 0;
 
     // end the effect
@@ -1490,4 +1489,5 @@ int CMaterialManager::EndMaterial (AssetHelper::MeshHelper* pcMesh)
 
     return 1;
 }
-}; // end namespace AssimpView
+
+} // end namespace AssimpView

tools/assimp_view/MessageProc.cpp

@@ -60,13 +60,13 @@ using namespace Assimp;
 COLORREF g_aclCustomColors[16] = {0};
 
 // Global registry key
-HKEY g_hRegistry = NULL;
+HKEY g_hRegistry = nullptr;
 
 // list of previous files (always 5)
 std::vector<std::string> g_aPreviousFiles;
 
 // history menu item
-HMENU g_hHistoryMenu = NULL;
+HMENU g_hHistoryMenu = nullptr;
 
 float g_fACMR = 3.0f;
 
@@ -89,10 +89,10 @@ void MakeFileAssociations() {
     char szTemp2[MAX_PATH];
     char szTemp[MAX_PATH + 10];
 
-    GetModuleFileName(NULL,szTemp2,MAX_PATH);
+    GetModuleFileName(nullptr,szTemp2,MAX_PATH);
     sprintf(szTemp,"%s %%1",szTemp2);
 
-    HKEY hRegistry = NULL;
+    HKEY hRegistry = nullptr;
 
     aiString list, tmp;
     aiGetExtensionList(&list);
@@ -104,15 +104,15 @@ void MakeFileAssociations() {
         ai_assert(sz[0] == '*');
         sprintf(buf,"Software\\Classes\\%s",sz+1);
 
-        RegCreateKeyEx(HKEY_CURRENT_USER,buf,0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL);
+        RegCreateKeyEx(HKEY_CURRENT_USER,buf,0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr);
         RegSetValueEx(hRegistry,"",0,REG_SZ,(const BYTE*)"ASSIMPVIEW_CLASS",(DWORD)strlen("ASSIMPVIEW_CLASS")+1);
         RegCloseKey(hRegistry);
     } while ((sz = strtok(nullptr,";")) != nullptr);
 
-    RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS",0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL);
+    RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr);
     RegCloseKey(hRegistry);
 
-    RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS\\shell\\open\\command",0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL);
+    RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS\\shell\\open\\command",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr);
     RegSetValueEx(hRegistry,"",0,REG_SZ,(const BYTE*)szTemp,(DWORD)strlen(szTemp)+1);
     RegCloseKey(hRegistry);
 
@@ -157,9 +157,9 @@ void HandleCommandLine(char* p_szCommand) {
 //-------------------------------------------------------------------------------
 void LoadLightColors() {
     DWORD dwTemp = 4;
-    RegQueryValueEx(g_hRegistry,"LightColor0",NULL,NULL, (BYTE*)&g_avLightColors[0],&dwTemp);
+    RegQueryValueEx(g_hRegistry,"LightColor0",nullptr,nullptr, (BYTE*)&g_avLightColors[0],&dwTemp);
-    RegQueryValueEx(g_hRegistry,"LightColor1",NULL,NULL, (BYTE*)&g_avLightColors[1],&dwTemp);
+    RegQueryValueEx(g_hRegistry,"LightColor1",nullptr,nullptr, (BYTE*)&g_avLightColors[1],&dwTemp);
-    RegQueryValueEx(g_hRegistry,"LightColor2",NULL,NULL, (BYTE*)&g_avLightColors[2],&dwTemp);
+    RegQueryValueEx(g_hRegistry,"LightColor2",nullptr,nullptr, (BYTE*)&g_avLightColors[2],&dwTemp);
 }
 
 //-------------------------------------------------------------------------------
@@ -190,10 +190,10 @@ void SaveCheckerPatternColors() {
 //-------------------------------------------------------------------------------
 void LoadCheckerPatternColors() {
     DWORD dwTemp = sizeof(D3DXVECTOR3);
-    RegQueryValueEx(g_hRegistry,"CheckerPattern0",NULL,NULL,
+    RegQueryValueEx(g_hRegistry,"CheckerPattern0",nullptr,nullptr,
         (BYTE*) /* jep, this is evil */ CDisplay::Instance().GetFirstCheckerColor(),&dwTemp);
 
-    RegQueryValueEx(g_hRegistry,"CheckerPattern1",NULL,NULL,
+    RegQueryValueEx(g_hRegistry,"CheckerPattern1",nullptr,nullptr,
         (BYTE*) /* jep, this is evil */ CDisplay::Instance().GetSecondCheckerColor(),&dwTemp);
 }
 
@@ -372,13 +372,13 @@ void ToggleUIState() {
     sRect2.top -= sRect.top;
 
     if (BST_UNCHECKED == IsDlgButtonChecked(g_hDlg,IDC_BLUBB)) {
-        SetWindowPos(g_hDlg,NULL,0,0,sRect.right-214,sRect.bottom,
+        SetWindowPos(g_hDlg,nullptr,0,0,sRect.right-214,sRect.bottom,
             SWP_NOMOVE | SWP_NOZORDER);
 
         SetWindowText(GetDlgItem(g_hDlg,IDC_BLUBB),">>");
         storeRegKey(false, "MultiSampling");
     } else {
-        SetWindowPos(g_hDlg,NULL,0,0,sRect.right+214,sRect.bottom,
+        SetWindowPos(g_hDlg,nullptr,0,0,sRect.right+214,sRect.bottom,
             SWP_NOMOVE | SWP_NOZORDER);
 
         storeRegKey(true, "LastUIState");
@@ -394,7 +394,7 @@ void LoadBGTexture() {
     char szFileName[MAX_PATH];
 
     DWORD dwTemp = MAX_PATH;
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureSrc",NULL,NULL, (BYTE*)szFileName,&dwTemp)) {
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureSrc",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) {
         // Key was not found. Use C:
         strcpy(szFileName,"");
     } else {
@@ -407,13 +407,13 @@ void LoadBGTexture() {
     }
     OPENFILENAME sFilename1 = {
         sizeof(OPENFILENAME),
-        g_hDlg,GetModuleHandle(NULL),
+        g_hDlg,GetModuleHandle(nullptr),
         "Textures\0*.png;*.dds;*.tga;*.bmp;*.tif;*.ppm;*.ppx;*.jpg;*.jpeg;*.exr\0*.*\0",
-        NULL, 0, 1,
+        nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        szFileName, MAX_PATH, nullptr, 0, nullptr,
         "Open texture as background",
         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-        0, 1, ".jpg", 0, NULL, NULL
+        0, 1, ".jpg", 0, nullptr, nullptr
     };
     if(GetOpenFileName(&sFilename1) == 0) return;
 
@@ -448,8 +448,8 @@ void DisplayColorDialog(D3DCOLOR* pclrResult) {
     clr.Flags = CC_RGBINIT | CC_FULLOPEN;
     clr.rgbResult = RGB((*pclrResult >> 16) & 0xff,(*pclrResult >> 8) & 0xff,*pclrResult & 0xff);
     clr.lpCustColors = g_aclCustomColors;
-    clr.lpfnHook = NULL;
+    clr.lpfnHook = nullptr;
-    clr.lpTemplateName = NULL;
+    clr.lpTemplateName = nullptr;
     clr.lCustData = 0;
 
     ChooseColor(&clr);
@@ -472,8 +472,8 @@ void DisplayColorDialog(D3DXVECTOR4* pclrResult) {
         clamp<unsigned char>(pclrResult->y * 255.0f),
         clamp<unsigned char>(pclrResult->z * 255.0f));
     clr.lpCustColors = g_aclCustomColors;
-    clr.lpfnHook = NULL;
+    clr.lpfnHook = nullptr;
-    clr.lpTemplateName = NULL;
+    clr.lpTemplateName = nullptr;
     clr.lCustData = 0;
 
     ChooseColor(&clr);
@@ -504,7 +504,7 @@ void LoadSkybox() {
     char szFileName[MAX_PATH];
 
     DWORD dwTemp = MAX_PATH;
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"SkyBoxSrc",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"SkyBoxSrc",nullptr,nullptr,
         (BYTE*)szFileName,&dwTemp))
     {
         // Key was not found. Use C:
@@ -521,12 +521,12 @@ void LoadSkybox() {
     }
     OPENFILENAME sFilename1 = {
         sizeof(OPENFILENAME),
-        g_hDlg,GetModuleHandle(NULL),
+        g_hDlg,GetModuleHandle(nullptr),
-        "Skyboxes\0*.dds\0*.*\0", NULL, 0, 1,
+        "Skyboxes\0*.dds\0*.*\0", nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        szFileName, MAX_PATH, nullptr, 0, nullptr,
         "Open skybox as background",
         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-        0, 1, ".dds", 0, NULL, NULL
+        0, 1, ".dds", 0, nullptr, nullptr
     };
     if(GetOpenFileName(&sFilename1) == 0) return;
 
@@ -555,7 +555,7 @@ void SaveScreenshot() {
     char szFileName[MAX_PATH];
 
     DWORD dwTemp = MAX_PATH;
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ScreenShot",NULL,NULL, (BYTE*)szFileName,&dwTemp)) {
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ScreenShot",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) {
         // Key was not found. Use C:
         strcpy(szFileName,"");
     } else {
@@ -568,21 +568,21 @@ void SaveScreenshot() {
     }
     OPENFILENAME sFilename1 = {
         sizeof(OPENFILENAME),
-        g_hDlg,GetModuleHandle(NULL),
+        g_hDlg,GetModuleHandle(nullptr),
-        "PNG Images\0*.png", NULL, 0, 1,
+        "PNG Images\0*.png", nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        szFileName, MAX_PATH, nullptr, 0, nullptr,
         "Save Screenshot to file",
         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-        0, 1, ".png", 0, NULL, NULL
+        0, 1, ".png", 0, nullptr, nullptr
     };
     if(GetSaveFileName(&sFilename1) == 0) return;
 
     // Now store the file in the registry
     RegSetValueExA(g_hRegistry,"ScreenShot",0,REG_SZ,(const BYTE*)szFileName,MAX_PATH);
 
-    IDirect3DSurface9* pi = NULL;
+    IDirect3DSurface9* pi = nullptr;
     g_piDevice->GetRenderTarget(0,&pi);
-    if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,D3DXIFF_PNG,pi,NULL,NULL))) {
+    if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,D3DXIFF_PNG,pi,nullptr,nullptr))) {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to save screenshot",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
     } else {
@@ -751,7 +751,7 @@ void LoadHistory() {
         DWORD dwTemp = MAX_PATH;
 
         szFileName[0] ='\0';
-        if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,szName,NULL,NULL,
+        if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,szName,nullptr,nullptr,
                 (BYTE*)szFileName,&dwTemp)) {
             g_aPreviousFiles[i] = std::string(szFileName);
         }
@@ -826,7 +826,7 @@ void OpenAsset() {
     char szFileName[MAX_PATH];
 
     DWORD dwTemp = MAX_PATH;
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"CurrentApp",NULL,NULL, (BYTE*)szFileName,&dwTemp)) {
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"CurrentApp",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) {
         // Key was not found. Use C:
         strcpy(szFileName,"");
     } else {
@@ -856,15 +856,15 @@ void OpenAsset() {
     ZeroMemory(&sFilename1, sizeof(sFilename1));
     sFilename1.lStructSize = sizeof(sFilename1);
     sFilename1.hwndOwner = g_hDlg;
-    sFilename1.hInstance = GetModuleHandle(NULL);
+    sFilename1.hInstance = GetModuleHandle(nullptr);
     sFilename1.lpstrFile = szFileName;
     sFilename1.lpstrFile[0] = '\0';
     sFilename1.nMaxFile = sizeof(szList);
     sFilename1.lpstrFilter = szList;
     sFilename1.nFilterIndex = 1;
-    sFilename1.lpstrFileTitle = NULL;
+    sFilename1.lpstrFileTitle = nullptr;
     sFilename1.nMaxFileTitle = 0;
-    sFilename1.lpstrInitialDir = NULL;
+    sFilename1.lpstrInitialDir = nullptr;
     sFilename1.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR;
     if (GetOpenFileName(&sFilename1) == 0) {
         return;
@@ -942,7 +942,7 @@ void DoExport(size_t formatId) {
 
     char szFileName[MAX_PATH*2];
     DWORD dwTemp = sizeof(szFileName);
-    if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,"ModelExportDest",NULL,NULL,(BYTE*)szFileName, &dwTemp)) {
+    if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,"ModelExportDest",nullptr,nullptr,(BYTE*)szFileName, &dwTemp)) {
         ai_assert(strlen(szFileName) <= MAX_PATH);
 
         // invent a nice default file name
@@ -975,12 +975,12 @@ void DoExport(size_t formatId) {
     const std::string ext = "."+std::string(e->fileExtension);
     OPENFILENAME sFilename1 = {
         sizeof(OPENFILENAME),
-        g_hDlg,GetModuleHandle(NULL),
+        g_hDlg,GetModuleHandle(nullptr),
-        desc, NULL, 0, 1,
+        desc, nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        szFileName, MAX_PATH, nullptr, 0, nullptr,
         "Export asset",
         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
-        0, 1, ext.c_str(), 0, NULL, NULL
+        0, 1, ext.c_str(), 0, nullptr, nullptr
     };
     if(::GetSaveFileName(&sFilename1) == 0) {
         return;
@@ -1036,9 +1036,9 @@ void InitUI() {
 
     // store the key in a global variable for later use
     RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\ASSIMP\\Viewer",
-        0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
+        0,nullptr,0,KEY_ALL_ACCESS, nullptr, &g_hRegistry,nullptr);
 
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LastUIState",NULL,NULL, (BYTE*)&dwValue,&dwTemp)) {
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LastUIState",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp)) {
         dwValue = 1;
     }
     if (0 == dwValue) {
@@ -1054,7 +1054,7 @@ void InitUI() {
         sRect2.left -= sRect.left;
         sRect2.top -= sRect.top;
 
-        SetWindowPos(g_hDlg,NULL,0,0,sRect.right-214,sRect.bottom,
+        SetWindowPos(g_hDlg,nullptr,0,0,sRect.right-214,sRect.bottom,
             SWP_NOMOVE | SWP_NOZORDER);
         SetWindowText(GetDlgItem(g_hDlg,IDC_BLUBB),">>");
     } else {
@@ -1062,7 +1062,7 @@ void InitUI() {
     }
 
     // AutoRotate
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"AutoRotate",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"AutoRotate",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_sOptions.bRotate = false;
@@ -1073,7 +1073,7 @@ void InitUI() {
     }
 
     // MultipleLights
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultipleLights",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultipleLights",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_sOptions.b3Lights = false;
@@ -1084,7 +1084,7 @@ void InitUI() {
     }
 
     // Light rotate
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LightRotate",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LightRotate",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_sOptions.bLightRotate = false;
@@ -1095,7 +1095,7 @@ void InitUI() {
     }
 
     // NoSpecular
-    if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "NoSpecular", NULL, NULL, (BYTE*)&dwValue, &dwTemp)) {
+    if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "NoSpecular", nullptr, nullptr, (BYTE*)&dwValue, &dwTemp)) {
         dwValue = 0;
     }
     if (0 == dwValue) {
@@ -1107,7 +1107,7 @@ void InitUI() {
     }
 
     // LowQuality
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LowQuality",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LowQuality",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_sOptions.bLowQuality = false;
@@ -1118,7 +1118,7 @@ void InitUI() {
     }
 
     // LowQuality
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"NoTransparency",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"NoTransparency",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_sOptions.bNoAlphaBlending = false;
@@ -1129,7 +1129,7 @@ void InitUI() {
     }
 
     // DisplayNormals
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"RenderNormals",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"RenderNormals",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_sOptions.bRenderNormals = false;
@@ -1140,7 +1140,7 @@ void InitUI() {
     }
 
     // NoMaterials
-    if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "RenderMats", NULL, NULL,
+    if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "RenderMats", nullptr, nullptr,
         (BYTE*)&dwValue, &dwTemp)) {
         dwValue = 1;
     }
@@ -1153,7 +1153,7 @@ void InitUI() {
     }
 
     // MultiSampling
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultiSampling",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultiSampling",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 1;
     if (0 == dwValue)
     {
@@ -1165,7 +1165,7 @@ void InitUI() {
     }
 
     // FPS Mode
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"FPSView",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"FPSView",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue) {
         g_bFPSView = false;
@@ -1176,7 +1176,7 @@ void InitUI() {
     }
 
     // WireFrame
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"Wireframe",NULL,NULL,
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"Wireframe",nullptr,nullptr,
         (BYTE*)&dwValue,&dwTemp))dwValue = 0;
     if (0 == dwValue)
     {
@@ -1189,7 +1189,7 @@ void InitUI() {
         CheckDlgButton(g_hDlg,IDC_TOGGLEWIRE,BST_CHECKED);
     }
 
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"PostProcessing",NULL,NULL,(BYTE*)&dwValue,&dwTemp))
+    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"PostProcessing",nullptr,nullptr,(BYTE*)&dwValue,&dwTemp))
         ppsteps = ppstepsdefault;
     else ppsteps = dwValue;
 
@@ -1458,7 +1458,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
                 if (bDraw)
                 {
                     SetBkColor(pcStruct->hDC,RGB(0,0,0));
-                    MoveToEx(pcStruct->hDC,0,0,NULL);
+                    MoveToEx(pcStruct->hDC,0,0,nullptr);
                     LineTo(pcStruct->hDC,sRect.right-1,0);
                     LineTo(pcStruct->hDC,sRect.right-1,sRect.bottom-1);
                     LineTo(pcStruct->hDC,0,sRect.bottom-1);
@@ -1534,7 +1534,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
             g_eClick = EClickPos_Outside;
             if (xPos2 >= fHalfX && xPos2 < fHalfX + (int)sDesc.Width &&
                 yPos2 >= fHalfY && yPos2 < fHalfY + (int)sDesc.Height &&
-                NULL != g_szImageMask)
+                nullptr != g_szImageMask)
                 {
                 // inside the texture. Lookup the grayscale value from it
                 xPos2 -= fHalfX;
@@ -1710,13 +1710,13 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
             } else if (ID_TOOLS_LOGWINDOW == LOWORD(wParam)) {
                 CLogWindow::Instance().Show();
             } else if (ID__WEBSITE == LOWORD(wParam)) {
-                ShellExecute(NULL,"open","http://assimp.sourceforge.net","","",SW_SHOW);
+                ShellExecute(nullptr,"open","http://assimp.sourceforge.net","","",SW_SHOW);
             } else if (ID__WEBSITESF == LOWORD(wParam)) {
-                ShellExecute(NULL,"open","https://sourceforge.net/projects/assimp","","",SW_SHOW);
+                ShellExecute(nullptr,"open","https://sourceforge.net/projects/assimp","","",SW_SHOW);
             }  else if (ID_REPORTBUG == LOWORD(wParam)) {
-                ShellExecute(NULL,"open","https://sourceforge.net/tracker/?func=add&group_id=226462&atid=1067632","","",SW_SHOW);
+                ShellExecute(nullptr,"open","https://sourceforge.net/tracker/?func=add&group_id=226462&atid=1067632","","",SW_SHOW);
             } else if (ID_FR == LOWORD(wParam)) {
-                ShellExecute(NULL,"open","https://sourceforge.net/forum/forum.php?forum_id=817653","","",SW_SHOW);
+                ShellExecute(nullptr,"open","https://sourceforge.net/forum/forum.php?forum_id=817653","","",SW_SHOW);
             } else if (ID_TOOLS_CLEARLOG == LOWORD(wParam)) {
                 CLogWindow::Instance().Clear();
             } else if (ID_TOOLS_SAVELOGTOFILE == LOWORD(wParam)) {
@@ -1838,7 +1838,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
             }
             else if (ID_IMPORTSETTINGS_OPENPOST == LOWORD(wParam))
             {
-                ShellExecute(NULL,"open","http://assimp.sourceforge.net/lib_html/ai_post_process_8h.html","","",SW_SHOW);
+                ShellExecute(nullptr,"open","http://assimp.sourceforge.net/lib_html/ai_post_process_8h.html","","",SW_SHOW);
             }
             else if (ID_TOOLS_ORIGINALNORMALS == LOWORD(wParam))
             {
@@ -1922,7 +1922,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
                         DisplayColorDialog(&g_avLightColors[0]);
                         SaveLightColors();
                     }
-                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),NULL,TRUE);
+                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),nullptr,TRUE);
                     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR1));
                     }
                 else if (IDC_LCOLOR2 == LOWORD(wParam))
@@ -1939,13 +1939,13 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
                         DisplayColorDialog(&g_avLightColors[1]);
                         SaveLightColors();
                     }
-                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE);
+                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE);
                     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR2));
                     }
                 else if (IDC_LCOLOR3 == LOWORD(wParam))
                     {
                     DisplayColorDialog(&g_avLightColors[2]);
-                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,TRUE);
+                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),nullptr,TRUE);
                     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR3));
                     SaveLightColors();
                 }
@@ -1966,11 +1966,11 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
                         SaveLightColors();
                     }
 
-                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),NULL,TRUE);
+                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),nullptr,TRUE);
                     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR1));
-                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE);
+                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE);
                     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR2));
-                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,TRUE);
+                    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),nullptr,TRUE);
                     UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR3));
                     }
                 else if (IDC_NOSPECULAR == LOWORD(wParam))
@@ -2076,7 +2076,7 @@ INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg,UINT uMsg,
             SendDlgItemMessage(hwndDlg,IDC_PROGRESS,PBM_SETRANGE,0,
                 MAKELPARAM(0,500));
 
-            SetTimer(hwndDlg,0,40,NULL);
+            SetTimer(hwndDlg,0,40,nullptr);
             return TRUE;
 
         case WM_CLOSE:
@@ -2090,7 +2090,7 @@ INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg,UINT uMsg,
 #if 0
                 g_bLoadingCanceled = true;
                 TerminateThread(g_hThreadHandle,5);
-                g_pcAsset = NULL;
+                g_pcAsset = nullptr;
 
                 EndDialog(hwndDlg,0);
 #endif
@@ -2167,14 +2167,14 @@ int APIENTRY _tWinMain(HINSTANCE hInstance,
     // initialize the IDirect3D9 interface
     g_hInstance = hInstance;
     if (0 == InitD3D()) {
-        MessageBox(NULL,"Failed to initialize Direct3D 9",
+        MessageBox(nullptr,"Failed to initialize Direct3D 9",
             "ASSIMP ModelViewer",MB_OK);
         return -6;
     }
 
     // create the main dialog
     HWND hDlg = CreateDialog(hInstance,MAKEINTRESOURCE(IDD_DIALOGMAIN),
-        NULL,&MessageProc);
+        nullptr,&MessageProc);
 
     // ensure we get high priority
     ::SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS);
@@ -2187,8 +2187,8 @@ int APIENTRY _tWinMain(HINSTANCE hInstance,
         Assimp::DefaultLogger::Debugging | Assimp::DefaultLogger::Info |
         Assimp::DefaultLogger::Err | Assimp::DefaultLogger::Warn);
 
-    if (NULL == hDlg) {
+    if (nullptr == hDlg) {
-        MessageBox(NULL,"Failed to create dialog from resource",
+        MessageBox(nullptr,"Failed to create dialog from resource",
             "ASSIMP ModelViewer",MB_OK);
         return -5;
     }
@@ -2202,7 +2202,7 @@ int APIENTRY _tWinMain(HINSTANCE hInstance,
 
     // create the D3D device object
     if (0 == CreateDevice(g_sOptions.bMultiSample,false,true)) {
-        MessageBox(NULL,"Failed to initialize Direct3D 9 (2)",
+        MessageBox(nullptr,"Failed to initialize Direct3D 9 (2)",
             "ASSIMP ModelViewer",MB_OK);
         return -4;
     }
@@ -2222,18 +2222,18 @@ int APIENTRY _tWinMain(HINSTANCE hInstance,
     };
     DWORD dwTemp = MAX_PATH;
     RegCreateKeyEx(HKEY_CURRENT_USER,
-        "Software\\ASSIMP\\Viewer",0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL);
+        "Software\\ASSIMP\\Viewer",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr);
-    if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastSkyBoxSrc",NULL,NULL,
+    if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastSkyBoxSrc",nullptr,nullptr,
         (BYTE*)szFileName,&dwTemp) && '\0' != szFileName[0])
         {
         CBackgroundPainter::Instance().SetCubeMapBG(szFileName);
         }
-    else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastTextureSrc",NULL,NULL,
+    else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastTextureSrc",nullptr,nullptr,
         (BYTE*)szFileName,&dwTemp) && '\0' != szFileName[0])
         {
         CBackgroundPainter::Instance().SetTextureBG(szFileName);
         }
-    else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"Color",NULL,NULL,
+    else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"Color",nullptr,nullptr,
         (BYTE*)&clrColor,&dwTemp))
         {
         CBackgroundPainter::Instance().SetColor(clrColor);
@@ -2251,7 +2251,7 @@ int APIENTRY _tWinMain(HINSTANCE hInstance,
     double g_dLastTime = 0;
     while( uMsg.message != WM_QUIT )
         {
-        if( PeekMessage( &uMsg, NULL, 0, 0, PM_REMOVE ) )
+        if( PeekMessage( &uMsg, nullptr, 0, 0, PM_REMOVE ) )
             {
             TranslateMessage( &uMsg );
             DispatchMessage( &uMsg );

tools/assimp_view/assimp_view.cpp

@@ -61,17 +61,17 @@ extern std::string g_szDefaultShader;
 extern std::string g_szPassThroughShader;
 
 //-------------------------------------------------------------------------------
-HINSTANCE g_hInstance				= NULL;
+HINSTANCE g_hInstance				= nullptr;
-HWND g_hDlg							= NULL;
+HWND g_hDlg							= nullptr;
-IDirect3D9* g_piD3D					= NULL;
+IDirect3D9* g_piD3D					= nullptr;
-IDirect3DDevice9* g_piDevice		= NULL;
+IDirect3DDevice9* g_piDevice		= nullptr;
-IDirect3DVertexDeclaration9* gDefaultVertexDecl = NULL;
+IDirect3DVertexDeclaration9* gDefaultVertexDecl = nullptr;
 double g_fFPS						= 0.0f;
 char g_szFileName[MAX_PATH];
-ID3DXEffect* g_piDefaultEffect		= NULL;
+ID3DXEffect* g_piDefaultEffect		= nullptr;
-ID3DXEffect* g_piNormalsEffect		= NULL;
+ID3DXEffect* g_piNormalsEffect		= nullptr;
-ID3DXEffect* g_piPassThroughEffect	= NULL;
+ID3DXEffect* g_piPassThroughEffect	= nullptr;
-ID3DXEffect* g_piPatternEffect		= NULL;
+ID3DXEffect* g_piPatternEffect		= nullptr;
 bool g_bMousePressed				= false;
 bool g_bMousePressedR				= false;
 bool g_bMousePressedM				= false;
@@ -79,10 +79,10 @@ bool g_bMousePressedBoth			= false;
 float g_fElpasedTime				= 0.0f;
 D3DCAPS9 g_sCaps;
 bool g_bLoadingFinished				= false;
-HANDLE g_hThreadHandle				= NULL;
+HANDLE g_hThreadHandle				= nullptr;
 float g_fWheelPos					= -10.0f;
 bool g_bLoadingCanceled				= false;
-IDirect3DTexture9* g_pcTexture		= NULL;
+IDirect3DTexture9* g_pcTexture		= nullptr;
 bool g_bPlay						= false;
 double g_dCurrent = 0.;
 
@@ -135,13 +135,13 @@ float g_fLightColor					= 1.0f;
 
 RenderOptions g_sOptions;
 Camera g_sCamera;
-AssetHelper *g_pcAsset				= NULL;
+AssetHelper *g_pcAsset				= nullptr;
 
 //
 // Contains the mask image for the HUD 
 // (used to determine the position of a click)
 //
-unsigned char* g_szImageMask		= NULL;
+unsigned char* g_szImageMask		= nullptr;
 
 float g_fLoadTime = 0.0f;
 
@@ -175,7 +175,7 @@ DWORD WINAPI LoadThreadProc(LPVOID lpParameter)
         aiProcess_ConvertToLeftHanded	   | // convert everything to D3D left handed space
         aiProcess_SortByPType              | // make 'clean' meshes which consist of a single typ of primitives
         0,
-        NULL,
+        nullptr,
         props);
 
     aiReleasePropertyStore(props);
@@ -186,7 +186,7 @@ DWORD WINAPI LoadThreadProc(LPVOID lpParameter)
     g_bLoadingFinished = true;
 
     // check whether the loading process has failed ...
-    if (NULL == g_pcAsset->pcScene)
+    if (nullptr == g_pcAsset->pcScene)
     {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load this asset:",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
@@ -223,7 +223,7 @@ int LoadAsset()
     DWORD dwID;
     g_bLoadingCanceled = false;
     g_pcAsset = new AssetHelper();
-    g_hThreadHandle = CreateThread(NULL,0,&LoadThreadProc,NULL,0,&dwID);
+    g_hThreadHandle = CreateThread(nullptr,0,&LoadThreadProc,nullptr,0,&dwID);
 
     if (!g_hThreadHandle)
     {
@@ -248,7 +248,7 @@ int LoadAsset()
         if (g_pcAsset)
         {
             delete g_pcAsset;
-            g_pcAsset = NULL;
+            g_pcAsset = nullptr;
         }
         return 0;
     }
@@ -328,7 +328,7 @@ int DeleteAsset(void) {
     delete[] g_pcAsset->apcMeshes;
     delete g_pcAsset->mAnimator;
     delete g_pcAsset;
-    g_pcAsset = NULL;
+    g_pcAsset = nullptr;
 
     // reset the caption of the viewer window
     SetWindowText(g_hDlg,AI_VIEW_CAPTION_BASE);
@@ -351,8 +351,8 @@ int DeleteAsset(void) {
 // piMatrix Transformation matrix of the graph at this position
 //-------------------------------------------------------------------------------
 int CalculateBounds(aiNode* piNode, aiVector3D* p_avOut, const aiMatrix4x4& piMatrix) {
-    ai_assert(NULL != piNode);
+    ai_assert(nullptr != piNode);
-    ai_assert(NULL != p_avOut);
+    ai_assert(nullptr != p_avOut);
 
     aiMatrix4x4 mTemp = piNode->mTransformation;
     mTemp.Transpose();
@@ -424,8 +424,8 @@ int ScaleAsset(void)
 //-------------------------------------------------------------------------------
 int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource)
 {
-    ai_assert(NULL != pcMesh);
+    ai_assert(nullptr != pcMesh);
-    ai_assert(NULL != pcSource);
+    ai_assert(nullptr != pcSource);
 
     if (!pcSource->mNormals)return 0;
 
@@ -434,7 +434,7 @@ int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSo
         pcSource->mNumVertices * 2,
         D3DUSAGE_WRITEONLY,
         AssetHelper::LineVertex::GetFVF(),
-        D3DPOOL_DEFAULT, &pcMesh->piVBNormals,NULL)))
+        D3DPOOL_DEFAULT, &pcMesh->piVBNormals,nullptr)))
     {
         CLogDisplay::Instance().AddEntry("Failed to create vertex buffer for the normal list",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
@@ -495,7 +495,7 @@ int CreateAssetData()
             mesh->mNumVertices,
             D3DUSAGE_WRITEONLY,
             0,
-            D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piVB,NULL)))	{
+            D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piVB,nullptr)))	{
             MessageBox(g_hDlg,"Failed to create vertex buffer",
                 "ASSIMP Viewer Utility",MB_OK);
             return 2;
@@ -534,7 +534,7 @@ int CreateAssetData()
                 D3DFMT_INDEX32,
                 D3DPOOL_DEFAULT, 
                 &g_pcAsset->apcMeshes[i]->piIB,
-                NULL)))
+                nullptr)))
             {
                 MessageBox(g_hDlg,"Failed to create 32 Bit index buffer",
                     "ASSIMP Viewer Utility",MB_OK);
@@ -560,7 +560,7 @@ int CreateAssetData()
                 D3DFMT_INDEX16,
                 D3DPOOL_DEFAULT,
                 &g_pcAsset->apcMeshes[i]->piIB,
-                NULL)))
+                nullptr)))
             {
                 MessageBox(g_hDlg,"Failed to create 16 Bit index buffer",
                     "ASSIMP Viewer Utility",MB_OK);
@@ -595,11 +595,11 @@ int CreateAssetData()
         {
             pbData2->vPosition = mesh->mVertices[x];
 
-            if (NULL == mesh->mNormals)
+            if (nullptr == mesh->mNormals)
                 pbData2->vNormal = aiVector3D(0.0f,0.0f,0.0f);
             else pbData2->vNormal = mesh->mNormals[x];
 
-            if (NULL == mesh->mTangents)	{
+            if (nullptr == mesh->mTangents)	{
                 pbData2->vTangent = aiVector3D(0.0f,0.0f,0.0f);
                 pbData2->vBitangent = aiVector3D(0.0f,0.0f,0.0f);
             }
@@ -677,17 +677,17 @@ int DeleteAssetData(bool bNoMaterials)
         if(g_pcAsset->apcMeshes[i]->piVB)
         {
             g_pcAsset->apcMeshes[i]->piVB->Release();
-            g_pcAsset->apcMeshes[i]->piVB = NULL;
+            g_pcAsset->apcMeshes[i]->piVB = nullptr;
         }
         if(g_pcAsset->apcMeshes[i]->piVBNormals)
         {
             g_pcAsset->apcMeshes[i]->piVBNormals->Release();
-            g_pcAsset->apcMeshes[i]->piVBNormals = NULL;
+            g_pcAsset->apcMeshes[i]->piVBNormals = nullptr;
         }
         if(g_pcAsset->apcMeshes[i]->piIB)
         {
             g_pcAsset->apcMeshes[i]->piIB->Release();
-            g_pcAsset->apcMeshes[i]->piIB = NULL;
+            g_pcAsset->apcMeshes[i]->piIB = nullptr;
         }
 
         // TODO ... unfixed memory leak
@@ -703,42 +703,42 @@ int DeleteAssetData(bool bNoMaterials)
             if(g_pcAsset->apcMeshes[i]->piEffect)
             {
                 g_pcAsset->apcMeshes[i]->piEffect->Release();
-                g_pcAsset->apcMeshes[i]->piEffect = NULL;
+                g_pcAsset->apcMeshes[i]->piEffect = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piDiffuseTexture)
             {
                 g_pcAsset->apcMeshes[i]->piDiffuseTexture->Release();
-                g_pcAsset->apcMeshes[i]->piDiffuseTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piDiffuseTexture = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piNormalTexture)
             {
                 g_pcAsset->apcMeshes[i]->piNormalTexture->Release();
-                g_pcAsset->apcMeshes[i]->piNormalTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piNormalTexture = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piSpecularTexture)
             {
                 g_pcAsset->apcMeshes[i]->piSpecularTexture->Release();
-                g_pcAsset->apcMeshes[i]->piSpecularTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piSpecularTexture = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piAmbientTexture)
             {
                 g_pcAsset->apcMeshes[i]->piAmbientTexture->Release();
-                g_pcAsset->apcMeshes[i]->piAmbientTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piAmbientTexture = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piEmissiveTexture)
             {
                 g_pcAsset->apcMeshes[i]->piEmissiveTexture->Release();
-                g_pcAsset->apcMeshes[i]->piEmissiveTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piEmissiveTexture = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piOpacityTexture)
             {
                 g_pcAsset->apcMeshes[i]->piOpacityTexture->Release();
-                g_pcAsset->apcMeshes[i]->piOpacityTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piOpacityTexture = nullptr;
             }
             if(g_pcAsset->apcMeshes[i]->piShininessTexture)
             {
                 g_pcAsset->apcMeshes[i]->piShininessTexture->Release();
-                g_pcAsset->apcMeshes[i]->piShininessTexture = NULL;
+                g_pcAsset->apcMeshes[i]->piShininessTexture = nullptr;
             }
         }
     }
@@ -776,10 +776,10 @@ int SetupFPSView()
 //-------------------------------------------------------------------------------
 int InitD3D(void)
 {
-    if (NULL == g_piD3D)
+    if (nullptr == g_piD3D)
     {
         g_piD3D = Direct3DCreate9(D3D_SDK_VERSION);
-        if (NULL == g_piD3D)return 0;
+        if (nullptr == g_piD3D)return 0;
     }
     return 1;
 }
@@ -792,10 +792,10 @@ int InitD3D(void)
 int ShutdownD3D(void)
 {
     ShutdownDevice();
-    if (NULL != g_piD3D)
+    if (nullptr != g_piD3D)
     {
         g_piD3D->Release();
-        g_piD3D = NULL;
+        g_piD3D = nullptr;
     }
     return 1;
 }
@@ -843,12 +843,12 @@ int ShutdownDevice(void)
 int CreateHUDTexture()
 {
     // lock the memory resource ourselves
-    HRSRC res = FindResource(NULL,MAKEINTRESOURCE(IDR_HUD),RT_RCDATA);
+    HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUD),RT_RCDATA);
-    HGLOBAL hg = LoadResource(NULL,res);
+    HGLOBAL hg = LoadResource(nullptr,res);
     void* pData = LockResource(hg);
 
     if(FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
-        pData,SizeofResource(NULL,res),
+        pData,SizeofResource(nullptr,res),
         D3DX_DEFAULT_NONPOW2,
         D3DX_DEFAULT_NONPOW2,
         1,
@@ -858,15 +858,15 @@ int CreateHUDTexture()
         D3DX_DEFAULT,
         D3DX_DEFAULT,
         0,
-        NULL,
+        nullptr,
-        NULL,
+        nullptr,
         &g_pcTexture)))
     {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD texture",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
 
-        g_pcTexture  = NULL;
+        g_pcTexture  = nullptr;
-        g_szImageMask = NULL;
+        g_szImageMask = nullptr;
 
         FreeResource(hg);
         return 0;
@@ -879,13 +879,13 @@ int CreateHUDTexture()
 
 
     // lock the memory resource ourselves
-    res = FindResource(NULL,MAKEINTRESOURCE(IDR_HUDMASK),RT_RCDATA);
+    res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUDMASK),RT_RCDATA);
-    hg = LoadResource(NULL,res);
+    hg = LoadResource(nullptr,res);
     pData = LockResource(hg);
 
     IDirect3DTexture9* pcTex;
     if(FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
-        pData,SizeofResource(NULL,res),
+        pData,SizeofResource(nullptr,res),
         sDesc.Width,
         sDesc.Height,
         1,
@@ -895,13 +895,13 @@ int CreateHUDTexture()
         D3DX_DEFAULT,
         D3DX_DEFAULT,
         0,
-        NULL,
+        nullptr,
-        NULL,
+        nullptr,
         &pcTex)))
     {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD mask texture",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
-        g_szImageMask = NULL;
+        g_szImageMask = nullptr;
 
         FreeResource(hg);
         return 0;
@@ -911,7 +911,7 @@ int CreateHUDTexture()
 
     // lock the texture and copy it to get a pointer
     D3DLOCKED_RECT sRect;
-    pcTex->LockRect(0,&sRect,NULL,D3DLOCK_READONLY);
+    pcTex->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY);
 
     unsigned char* szOut = new unsigned char[sDesc.Width * sDesc.Height];
     unsigned char* _szOut = szOut;
@@ -1023,14 +1023,14 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     }
 
     // compile the default material shader (gray gouraud/phong)
-    ID3DXBuffer* piBuffer = NULL;
+    ID3DXBuffer* piBuffer = nullptr;
     if(FAILED( D3DXCreateEffect(g_piDevice,
         g_szDefaultShader.c_str(),
         (UINT)g_szDefaultShader.length(),
-        NULL,
+        nullptr,
-        NULL,
+        nullptr,
         AI_SHADER_COMPILE_FLAGS,
-        NULL,
+        nullptr,
         &g_piDefaultEffect,&piBuffer)))
     {
         if( piBuffer) 
@@ -1043,7 +1043,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     if( piBuffer) 
     {
         piBuffer->Release();
-        piBuffer = NULL;
+        piBuffer = nullptr;
     }
 
     // use Fixed Function effect when working with shaderless cards
@@ -1053,7 +1053,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     // create the shader used to draw the HUD
     if(FAILED( D3DXCreateEffect(g_piDevice,
         g_szPassThroughShader.c_str(),(UINT)g_szPassThroughShader.length(),
-        NULL,NULL,AI_SHADER_COMPILE_FLAGS,NULL,&g_piPassThroughEffect,&piBuffer)))
+        nullptr,nullptr,AI_SHADER_COMPILE_FLAGS,nullptr,&g_piPassThroughEffect,&piBuffer)))
     {
         if( piBuffer) 
         {
@@ -1065,7 +1065,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     if( piBuffer) 
     {
         piBuffer->Release();
-        piBuffer = NULL;
+        piBuffer = nullptr;
     }
 
     // use Fixed Function effect when working with shaderless cards
@@ -1075,7 +1075,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     // create the shader used to visualize normal vectors
     if(FAILED( D3DXCreateEffect(g_piDevice,
         g_szNormalsShader.c_str(),(UINT)g_szNormalsShader.length(),
-        NULL,NULL,AI_SHADER_COMPILE_FLAGS,NULL,&g_piNormalsEffect, &piBuffer)))
+        nullptr,nullptr,AI_SHADER_COMPILE_FLAGS,nullptr,&g_piNormalsEffect, &piBuffer)))
     {
         if( piBuffer) 
         {
@@ -1087,7 +1087,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     if( piBuffer) 
     {
         piBuffer->Release();
-        piBuffer = NULL;
+        piBuffer = nullptr;
     }
 
     //MessageBox( g_hDlg, "Failed to create vertex declaration", "Init", MB_OK);