Merge branch 'master' into master

include/assimp/Base64.hpp

@@ -43,6 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_BASE64_HPP_INC
 #define AI_BASE64_HPP_INC
 
+#include <assimp/defs.h>
+
 #include <stdint.h>
 #include <vector>
 #include <string>
@@ -54,35 +56,35 @@ namespace Base64 {
 /// @param in           The UTF-64 buffer.
 /// @param inLength     The size of the buffer
 /// @param out          The encoded ASCII string.
-void Encode(const uint8_t *in, size_t inLength, std::string &out);
+ASSIMP_API void Encode(const uint8_t *in, size_t inLength, std::string &out);
 
 /// @brief Will encode the given character buffer from UTF64 to ASCII.
 /// @param in   A vector, which contains the buffer for encoding.
 /// @param out  The encoded ASCII string.
-void Encode(const std::vector<uint8_t>& in, std::string &out);
+ASSIMP_API void Encode(const std::vector<uint8_t> &in, std::string &out);
 
 /// @brief Will encode the given character buffer from UTF64 to ASCII.
 /// @param in   A vector, which contains the buffer for encoding.
 /// @return The encoded ASCII string.
-std::string Encode(const std::vector<uint8_t>& in);
+ASSIMP_API std::string Encode(const std::vector<uint8_t> &in);
 
 /// @brief Will decode the given character buffer from ASCII to UTF64.
 /// @param in           The ASCII buffer to decode.
 /// @param inLength     The size of the buffer.
 /// @param out          The decoded buffer.
 /// @return The new buffer size.
-size_t Decode(const char *in, size_t inLength, uint8_t *&out);
+ASSIMP_API size_t Decode(const char *in, size_t inLength, uint8_t *&out);
 
 /// @brief Will decode the given character buffer from ASCII to UTF64.
 /// @param in   The ASCII buffer to decode as a std::string.
 /// @param out  The decoded buffer.
 /// @return The new buffer size.
-size_t Decode(const std::string& in, std::vector<uint8_t>& out);
+ASSIMP_API size_t Decode(const std::string &in, std::vector<uint8_t> &out);
 
 /// @brief Will decode the given character buffer from ASCII to UTF64.
 /// @param in   The ASCII string.
 /// @return The decoded buffer in a vector.
-std::vector<uint8_t> Decode(const std::string& in);
+ASSIMP_API std::vector<uint8_t> Decode(const std::string &in);
 
 } // namespace Base64
 } // namespace Assimp

include/assimp/types.h

@@ -73,6 +73,12 @@ typedef uint32_t ai_uint32;
 
 #ifdef __cplusplus
 
+#ifdef ASSIMP_USE_HUNTER
+#   include <utf8.h>
+#else
+#   include "../contrib/utf8cpp/source/utf8.h"
+#endif
+
 #include <cstring>
 #include <new> // for std::nothrow_t
 #include <string> // for aiString::Set(const std::string&)

samples/SharedCode/UTFConverter.cpp

@@ -1,52 +0,0 @@
-/*
----------------------------------------------------------------------------
-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 "UTFConverter.h"
-
-namespace AssimpSamples {
-namespace SharedCode {
-
-typename UTFConverter::UTFConverterImpl UTFConverter::impl_;
-
-}
-}

samples/SharedCode/UTFConverter.h

@@ -1,92 +0,0 @@
-/*
----------------------------------------------------------------------------
-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.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
-#define ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
-
-#include <string>
-#include <locale>
-#include <codecvt>
-
-namespace AssimpSamples {
-namespace SharedCode {
-
-// Used to convert between multibyte and unicode strings.
-class UTFConverter {
-    using UTFConverterImpl = std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>;
-public:
-    UTFConverter(const char* s) :
-        s_(s),
-        ws_(impl_.from_bytes(s)) {
-    }
-    UTFConverter(const wchar_t* s) :
-        s_(impl_.to_bytes(s)),
-        ws_(s) {
-    }
-    UTFConverter(const std::string& s) :
-        s_(s),
-        ws_(impl_.from_bytes(s)) {
-    }
-    UTFConverter(const std::wstring& s) :
-        s_(impl_.to_bytes(s)),
-        ws_(s) {
-    }
-    inline const char* c_str() const {
-        return s_.c_str();
-    }
-    inline const std::string& str() const {
-        return s_;
-    }
-    inline const wchar_t* c_wstr() const {
-        return ws_.c_str();
-    }
-private:
-    static UTFConverterImpl impl_;
-    std::string s_;
-    std::wstring ws_;
-};
-
-}
-}
-
-#endif // ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H

samples/SimpleTexturedDirectx11/CMakeLists.txt

@@ -36,8 +36,6 @@ ADD_EXECUTABLE( assimp_simpletextureddirectx11 WIN32
   #SimpleTexturedDirectx11/VertexShader.hlsl
   SimpleTexturedDirectx11/main.cpp
   SimpleTexturedDirectx11/SafeRelease.hpp
-  ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
-  ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
 )
 
 TARGET_USE_COMMON_OUTPUT_DIRECTORY(assimp_simpletextureddirectx11)

samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp

@@ -13,6 +13,8 @@
 // Written by IAS. :)
 // ---------------------------------------------------------------------------
 
+#include <assimp/types.h>
+
 #include <Windows.h>
 #include <shellapi.h>
 #include <stdexcept>
@@ -21,8 +23,8 @@
 #include <dxgi1_2.h>
 #include <DirectXMath.h>
 #include <d3dcompiler.h>
+
 #include "ModelLoader.h"
-#include "UTFConverter.h"
 #include "SafeRelease.hpp"
 
 #ifdef _MSC_VER
@@ -33,7 +35,6 @@
 #endif // _MSC_VER
 
 using namespace DirectX;
-using namespace AssimpSamples::SharedCode;
 
 #define VERTEX_SHADER_FILE L"VertexShader.hlsl"
 #define PIXEL_SHADER_FILE L"PixelShader.hlsl"
@@ -50,10 +51,10 @@ struct ConstantBuffer {
 // ------------------------------------------------------------
 //                        Window Variables
 // ------------------------------------------------------------
-#define SCREEN_WIDTH  800
+static constexpr uint32_t SCREEN_WIDTH = 800;
-#define SCREEN_HEIGHT 600
+static constexpr uint32_t SCREEN_HEIGHT = 600;
 
-const char g_szClassName[] = "directxWindowClass";
+constexpr char g_szClassName[] = "directxWindowClass";
 
 static std::string g_ModelPath;
 
@@ -154,8 +155,14 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
 	}
 
 	// Retrieve the model file path.
-	g_ModelPath = UTFConverter(argv[1]).str();
+    std::wstring filename(argv[1]);
+    
+	char *targetStart = new char[filename.size()+1];
+    memset(targetStart, '\0', filename.size() + 1);
 
+	utf8::utf16to8(filename.c_str(), filename.c_str() + filename.size(), targetStart);
+    g_ModelPath = targetStart;
+    delete[] targetStart;
 	free_command_line_allocated_memory();
 
 	WNDCLASSEX wc;
@@ -511,9 +518,9 @@ void InitPipeline()
 {
 	ID3DBlob *VS, *PS;
 	if(FAILED(CompileShaderFromFile(SHADER_PATH VERTEX_SHADER_FILE, 0, "main", "vs_4_0", &VS)))
-		Throwanerror(UTFConverter(L"Failed to compile shader from file " VERTEX_SHADER_FILE).c_str());
+		Throwanerror("Failed to compile shader from file");
 	if(FAILED(CompileShaderFromFile(SHADER_PATH PIXEL_SHADER_FILE, 0, "main", "ps_4_0", &PS)))
-		Throwanerror(UTFConverter(L"Failed to compile shader from file " PIXEL_SHADER_FILE).c_str());
+		Throwanerror("Failed to compile shader from file ");
 
 	dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), nullptr, &pVS);
 	dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), nullptr, &pPS);

samples/SimpleTexturedOpenGL/CMakeLists.txt

@@ -30,8 +30,6 @@ LINK_DIRECTORIES(
 
 ADD_EXECUTABLE( assimp_simpletexturedogl WIN32
   SimpleTexturedOpenGL/src/model_loading.cpp
-  ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
-  ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
 )
 
 TARGET_USE_COMMON_OUTPUT_DIRECTORY(assimp_simpletexturedogl)

samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp

@@ -41,15 +41,14 @@
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/LogStream.hpp>
-#include "UTFConverter.h"
 
 // The default hard-coded path. Can be overridden by supplying a path through the command line.
 static std::string modelpath = "../../test/models/OBJ/spider.obj";
 
-HGLRC       hRC=nullptr;            // Permanent Rendering Context
+HGLRC       hRC = nullptr;         // Permanent Rendering Context
-HDC         hDC=nullptr;            // Private GDI Device Context
+HDC         hDC = nullptr;            // Private GDI Device Context
-HWND        g_hWnd=nullptr;         // Holds Window Handle
+HWND        g_hWnd = nullptr;         // Holds Window Handle
-HINSTANCE   g_hInstance=nullptr;    // Holds The Instance Of The Application
+HINSTANCE   g_hInstance = nullptr;    // Holds The Instance Of The Application
 
 bool		keys[256];			// Array used for Keyboard Routine;
 bool		active=TRUE;		// Window Active Flag Set To TRUE by Default
@@ -69,8 +68,6 @@ GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f };
 GLfloat LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f };
 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f };
 
-
-
 // the global Assimp scene object
 const aiScene* g_scene = nullptr;
 GLuint scene_list = 0;
@@ -83,12 +80,8 @@ GLuint*		textureIds;							// pointer to texture Array
 // Create an instance of the Importer class
 Assimp::Importer importer;
 
-using namespace AssimpSamples::SharedCode;
+void createAILogger() {
-
+    // Change this line to normal if you not want to analyze the import process
-void createAILogger()
-{
-    // Change this line to normal if you not want to analyse the import process
-	//Assimp::Logger::LogSeverity severity = Assimp::Logger::NORMAL;
 	Assimp::Logger::LogSeverity severity = Assimp::Logger::VERBOSE;
 
 	// Create a logger instance for Console Output
@@ -101,62 +94,52 @@ void createAILogger()
 	Assimp::DefaultLogger::get()->info("this is my info-call");
 }
 
-void destroyAILogger()
+void destroyAILogger() {
-{
-	// Kill it after the work is done
 	Assimp::DefaultLogger::kill();
 }
 
-void logInfo(std::string logString)
+void logInfo(const std::string &logString) {
-{
-	// Will add message to File with "info" Tag
 	Assimp::DefaultLogger::get()->info(logString.c_str());
 }
 
-void logDebug(const char* logString)
+void logDebug(const char* logString) {
-{
-	// Will add message to File with "debug" Tag
 	Assimp::DefaultLogger::get()->debug(logString);
 }
 
 
-bool Import3DFromFile( const std::string& pFile)
+bool Import3DFromFile( const std::string &filename) {
-{
 	// Check if file exists
-	std::ifstream fin(pFile.c_str());
+    std::ifstream fin(filename.c_str());
-	if(!fin.fail())
+	if(fin.fail()) {
-	{
+        std::string message = "Couldn't open file: " + filename;
-		fin.close();
+		std::wstring targetMessage;
+        //utf8::utf8to16(message.c_str(), message.c_str() + message.size(), targetMessage);
+        ::MessageBox(nullptr, targetMessage.c_str(), L"Error", MB_OK | MB_ICONEXCLAMATION);
+        logInfo(importer.GetErrorString());
+        return false;
 	}
-	else
+    
-	{
+	fin.close();
-		MessageBox(nullptr, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
+	
-		logInfo( importer.GetErrorString());
+	g_scene = importer.ReadFile(filename, aiProcessPreset_TargetRealtime_Quality);
-		return false;
-	}
-
-	g_scene = importer.ReadFile(pFile, aiProcessPreset_TargetRealtime_Quality);
 
 	// If the import failed, report it
-	if(!g_scene)
+	if (g_scene == nullptr) {
-	{
 		logInfo( importer.GetErrorString());
 		return false;
 	}
 
 	// Now we can access the file's contents.
-	logInfo("Import of scene " + pFile + " succeeded.");
+    logInfo("Import of scene " + filename + " succeeded.");
 
 	// We're done. Everything will be cleaned up by the importer destructor
 	return true;
 }
 
 // Resize And Initialize The GL Window
-void ReSizeGLScene(GLsizei width, GLsizei height)
+void ReSizeGLScene(GLsizei width, GLsizei height) {
-{
     // Prevent A Divide By Zero By
-	if (height==0)
+	if (height == 0) {
-	{
         // Making Height Equal One
         height=1;
 	}
@@ -174,43 +157,26 @@ void ReSizeGLScene(GLsizei width, GLsizei height)
 }
 
 
-std::string getBasePath(const std::string& path)
+std::string getBasePath(const std::string& path) {
-{
 	size_t pos = path.find_last_of("\\/");
 	return (std::string::npos == pos) ? "" : path.substr(0, pos + 1);
 }
 
-void freeTextureIds()
+void freeTextureIds() {
-{
+    // no need to delete pointers in it manually here. (Pointers point to textureIds deleted in next step)
-	textureIdMap.clear(); //no need to delete pointers in it manually here. (Pointers point to textureIds deleted in next step)
+	textureIdMap.clear();
 
-	if (textureIds)
+	if (textureIds) {
-	{
 		delete[] textureIds;
 		textureIds = nullptr;
 	}
 }
 
-int LoadGLTextures(const aiScene* scene)
+int LoadGLTextures(const aiScene* scene) {
-{
 	freeTextureIds();
 
-	//ILboolean success;
+    if (scene->HasTextures()) 
-
+		return 1;
-	/* Before calling ilInit() version should be checked. */
-	/*if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION)
-	{
-		/// wrong DevIL version ///
-		std::string err_msg = "Wrong DevIL version. Old devil.dll in system32/SysWow64?";
-		char* cErr_msg = (char *) err_msg.c_str();
-		abortGLInit(cErr_msg);
-		return -1;
-	}*/
-
-	//ilInit(); /* Initialization of DevIL */
-
-    if (scene->HasTextures()) return 1;
-        //abortGLInit("Support for meshes with embedded textures is not implemented");
 
 	/* getTexture Filenames and Numb of Textures */
 	for (unsigned int m=0; m<scene->mNumMaterials; m++)
@@ -230,14 +196,6 @@ int LoadGLTextures(const aiScene* scene)
 
 	const size_t numTextures = textureIdMap.size();
 
-
-	/* array with DevIL image IDs */
-	//ILuint* imageIds = NULL;
-//	imageIds = new ILuint[numTextures];
-
-	/* generate DevIL Image IDs */
-//	ilGenImages(numTextures, imageIds); /* Generation of numTextures image names */
-
 	/* create and fill array with GL texture ids */
 	textureIds = new GLuint[numTextures];
 	glGenTextures(static_cast<GLsizei>(numTextures), textureIds); /* Texture name generation */
@@ -248,29 +206,17 @@ int LoadGLTextures(const aiScene* scene)
 	std::string basepath = getBasePath(modelpath);
 	for (size_t i=0; i<numTextures; i++)
 	{
-
-		//save IL image ID
 		std::string filename = (*itr).first;  // get filename
 		(*itr).second =  &textureIds[i];	  // save texture id for filename in map
 		itr++;								  // next texture
 
 
-		//ilBindImage(imageIds[i]); /* Binding of DevIL image name */
 		std::string fileloc = basepath + filename;	/* Loading of image */
-		//success = ilLoadImage(fileloc.c_str());
         int x, y, n;
         unsigned char *data = stbi_load(fileloc.c_str(), &x, &y, &n, STBI_rgb_alpha);
 
 		if (nullptr != data )
 		{
-            // Convert every colour component into unsigned byte.If your image contains
-            // alpha channel you can replace IL_RGB with IL_RGBA
-            //success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
-			/*if (!success)
-			{
-				abortGLInit("Couldn't convert image");
-				return -1;
-			}*/
             // Binding of texture name
             glBindTexture(GL_TEXTURE_2D, textureIds[i]);
 			// redefine standard texture values
@@ -287,19 +233,18 @@ int LoadGLTextures(const aiScene* scene)
             glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
             glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 );
             stbi_image_free(data);
-        }
+        } else {
-		else
+            /* Error occurred */
-		{
+            const std::string message = "Couldn't load Image: " + fileloc;
-			/* Error occurred */
+            std::wstring targetMessage;
-			MessageBox(nullptr, UTFConverter("Couldn't load Image: " + fileloc).c_wstr(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
+            wchar_t *tmp = new wchar_t[message.size() + 1];
+            memset(tmp, L'\0', sizeof(wchar_t) *(message.size() + 1));
+            utf8::utf8to16(message.c_str(), message.c_str() + message.size(), tmp);
+            targetMessage = tmp;
+            delete [] tmp;
+            MessageBox(nullptr, targetMessage.c_str(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
 		}
 	}
-    // Because we have already copied image data into texture data  we can release memory used by image.
-//	ilDeleteImages(numTextures, imageIds);
-
-	// Cleanup
-	//delete [] imageIds;
-	//imageIds = NULL;
 
 	return TRUE;
 }
@@ -312,7 +257,6 @@ int InitGL()
 		return FALSE;
 	}
 
-
 	glEnable(GL_TEXTURE_2D);
 	glShadeModel(GL_SMOOTH);		 // Enables Smooth Shading
 	glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
@@ -537,9 +481,7 @@ int DrawGLScene()				//Here's where we do all the drawing
 
 	drawAiScene(g_scene);
 
-	//xrot+=0.3f;
+	yrot += 0.2f;
-	yrot+=0.2f;
-	//zrot+=0.4f;
 
 	return TRUE;					// okay
 }
@@ -591,8 +533,18 @@ void KillGLWindow()			// Properly Kill The Window
 
 GLboolean abortGLInit(const char* abortMessage)
 {
-	KillGLWindow();									// Reset Display
+    // Reset Display
-	MessageBox(nullptr, UTFConverter(abortMessage).c_wstr(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION);
+	KillGLWindow();
+    const std::string message = abortMessage;
+    std::wstring targetMessage;
+    const size_t len = std::strlen(abortMessage) + 1;
+    wchar_t *tmp = new wchar_t[len];
+    memset(tmp, L'\0', len);
+    utf8::utf8to16(message.c_str(), message.c_str() + message.size(), tmp);
+    targetMessage = tmp;
+    delete [] tmp;
+
+	MessageBox(nullptr, targetMessage.c_str(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION);
 	return FALSE;									// quit and return False
 }
 
@@ -642,7 +594,8 @@ 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(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)
+			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)
 			}
@@ -669,9 +622,16 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
 
 	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);		// Adjust Window To True Requested Size
 
-	if (nullptr == (g_hWnd=CreateWindowEx(dwExStyle,			// Extended Style For The Window
+    const size_t len = std::strlen(title) + 1;
+    wchar_t *tmp = new wchar_t[len];
+    memset(tmp, L'\0', sizeof(wchar_t) * len);
+    utf8::utf8to16(title, title+len, tmp);
+    std::wstring targetMessage = tmp;
+    delete[] tmp;
+
+	if (nullptr == (g_hWnd = CreateWindowEx(dwExStyle,			// Extended Style For The Window
 								TEXT("OpenGL"),						// Class Name
-								UTFConverter(title).c_wstr(),							// Window Title
+								targetMessage.c_str(), // Window Title
 								WS_CLIPSIBLINGS |				// Required Window Style
 								WS_CLIPCHILDREN |				// Required Window Style
 								dwStyle,						// Selected WIndow Style
@@ -843,7 +803,11 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/,     // The instance
 	if (argv != nullptr && argc > 1)
 	{
 		std::wstring modelpathW(argv[1]);
-		modelpath = UTFConverter(modelpathW).str();
+        char *tmp = new char[modelpathW.size() + 1];
+        memset(tmp, '\0', modelpathW.size() + 1);
+        utf8::utf16to8(modelpathW.c_str(), modelpathW.c_str() + modelpathW.size(), tmp);
+        modelpath = tmp;
+        delete[]tmp;
 	}
 
 	if (!Import3DFromFile(modelpath))
@@ -871,7 +835,7 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/,     // The instance
 		{
 			if (msg.message==WM_QUIT)
 			{
-				done=TRUE;
+				done = TRUE;
 			}
 			else
 			{

tools/assimp_view/AnimEvaluator.cpp

@@ -55,12 +55,6 @@ AnimEvaluator::AnimEvaluator(const aiAnimation *pAnim) :
     mLastPositions.resize(pAnim->mNumChannels, std::make_tuple(0, 0, 0));
 }
 
-// ------------------------------------------------------------------------------------------------
-// Destructor.
-AnimEvaluator::~AnimEvaluator() {
-    // empty
-}
-
 // ------------------------------------------------------------------------------------------------
 // Evaluates the animation tracks for a given time stamp.
 void AnimEvaluator::Evaluate(double pTime) {

tools/assimp_view/AnimEvaluator.h

@@ -66,7 +66,7 @@ public:
     AnimEvaluator(const aiAnimation *pAnim);
 
     /// @brief  The class destructor.
-    ~AnimEvaluator();
+    ~AnimEvaluator() = default;
 
     /// @brief Evaluates the animation tracks for a given time stamp.
     /// The calculated pose can be retrieved as an array of transformation

tools/assimp_view/AssetHelper.h

@@ -77,6 +77,13 @@ public:
         pcScene = NULL;
     }
 
+    // set the normal set to be used
+    void SetNormalSet(unsigned int iSet);
+
+    // flip all normal vectors
+    void FlipNormals();
+    void FlipNormalsInt();
+
     //---------------------------------------------------------------
     // default vertex data structure
     // (even if tangents, bitangents or normals aren't
@@ -221,16 +228,8 @@ public:
 
     // Specifies the normal set to be used
     unsigned int iNormalSet;
-
-    // ------------------------------------------------------------------
-    // set the normal set to be used
-    void SetNormalSet(unsigned int iSet);
-
-    // ------------------------------------------------------------------
-    // flip all normal vectors
-    void FlipNormals();
-    void FlipNormalsInt();
 };
+
 } // namespace AssimpView
 
 #endif // !! IG

tools/assimp_view/Material.cpp

@@ -175,33 +175,29 @@ VOID WINAPI FillFunc(D3DXVECTOR4* pOut,
         pOut->x = pOut->y = 1.0f;
         pOut->z = 0.0f;
     }
-    return;
 }
 
 //-------------------------------------------------------------------------------
-int CMaterialManager::UpdateSpecularMaterials()
+int CMaterialManager::UpdateSpecularMaterials() {
-    {
+    if (g_pcAsset && g_pcAsset->pcScene) {
-    if (g_pcAsset && g_pcAsset->pcScene)
+        for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i) {
-        {
+            if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode) {
-        for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-            {
-            if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode)
-                {
                 this->DeleteMaterial(g_pcAsset->apcMeshes[i]);
                 this->CreateMaterial(g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]);
-                }
             }
         }
-    return 1;
     }
+    return 1;
+}
+
 //-------------------------------------------------------------------------------
-int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut)
+int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut) {
-{
     if  (sDefaultTexture) {
         sDefaultTexture->AddRef();
         *p_ppiOut = sDefaultTexture;
         return 1;
     }
+
     if(FAILED(g_piDevice->CreateTexture(
         256,
         256,

tools/assimp_view/assimp_view.cpp

@@ -145,9 +145,7 @@ float g_fLoadTime = 0.0f;
 // The loader thread loads the asset while the progress dialog displays the
 // smart progress bar
 //-------------------------------------------------------------------------------
-DWORD WINAPI LoadThreadProc(LPVOID lpParameter) {
+DWORD WINAPI LoadThreadProc(LPVOID) {
-    UNREFERENCED_PARAMETER(lpParameter);
-
     // get current time
     double fCur = (double)timeGetTime();
 
@@ -367,7 +365,7 @@ int CalculateBounds(aiNode *piNode, aiVector3D *p_avOut, const aiMatrix4x4 &piMa
 // The function calculates the boundaries of the mesh and modifies the
 // global world transformation matrix according to the aset AABB
 //-------------------------------------------------------------------------------
-int ScaleAsset(void) {
+int ScaleAsset() {
     aiVector3D aiVecs[2] = { aiVector3D(1e10f, 1e10f, 1e10f),
         aiVector3D(-1e10f, -1e10f, -1e10f) };
 
@@ -521,8 +519,7 @@ int CreateAssetData() {
             }
         } else {
             // create 16 bit index buffer
-            if (FAILED(g_piDevice->CreateIndexBuffer(2 *
+            if (FAILED(g_piDevice->CreateIndexBuffer(2 * numIndices,
-numIndices,
                         D3DUSAGE_WRITEONLY | dwUsage,
                         D3DFMT_INDEX16,
                         D3DPOOL_DEFAULT,

tools/assimp_view/assimp_view.h

@@ -98,6 +98,12 @@ namespace AssimpView {
 //-------------------------------------------------------------------------------
 // Function prototypes
 //-------------------------------------------------------------------------------
+class AssimpVew {
+public:
+    AssimpVew();
+    ~AssimpVew();
+};
+
 int InitD3D(void);
 int ShutdownD3D(void);
 int CreateDevice(bool p_bMultiSample, bool p_bSuperSample, bool bHW = true);