v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #4986 from assimp/kimkulling/fix_sample_utf8_encoding 

Fix: Use C++17 compliant utf8 encoding.
pull/4994/head^2
Kim Kulling 2023-03-07 19:27:06 +01:00 committed by GitHub
parent 6ed433d011 4f48348af8
commit 3a73ce37e4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 130 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/assimp/Base64.hpp
View File

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

6
include/assimp/types.h
View File

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

52
samples/SharedCode/UTFConverter.cpp
View File

@ -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_;
}
}

92
samples/SharedCode/UTFConverter.h
View File

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

2
samples/SimpleTexturedDirectx11/CMakeLists.txt
View File

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

23
samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
View File

@ -13,6 +13,8 @@
// Written by IAS. :) // Written by IAS. :)
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
#include <assimp/types.h>
#include <Windows.h> #include <Windows.h>
#include <shellapi.h> #include <shellapi.h>
#include <stdexcept> #include <stdexcept>
@ -21,8 +23,8 @@
#include <dxgi1_2.h> #include <dxgi1_2.h>
#include <DirectXMath.h> #include <DirectXMath.h>
#include <d3dcompiler.h> #include <d3dcompiler.h>
#include "ModelLoader.h" #include "ModelLoader.h"
#include "UTFConverter.h"
#include "SafeRelease.hpp" #include "SafeRelease.hpp"
#ifdef _MSC_VER #ifdef _MSC_VER
@ -33,7 +35,6 @@
#endif // _MSC_VER #endif // _MSC_VER
using namespace DirectX; using namespace DirectX;
using namespace AssimpSamples::SharedCode;
#define VERTEX_SHADER_FILE L"VertexShader.hlsl" #define VERTEX_SHADER_FILE L"VertexShader.hlsl"
#define PIXEL_SHADER_FILE L"PixelShader.hlsl" #define PIXEL_SHADER_FILE L"PixelShader.hlsl"
@ -50,10 +51,10 @@ struct ConstantBuffer {
// ------------------------------------------------------------ // ------------------------------------------------------------
// Window Variables // 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; static std::string g_ModelPath;
@ -154,8 +155,14 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
} }
// Retrieve the model file path. // 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(); free_command_line_allocated_memory();
WNDCLASSEX wc; WNDCLASSEX wc;
@ -511,9 +518,9 @@ void InitPipeline()
{ {
ID3DBlob *VS, *PS; ID3DBlob *VS, *PS;
if(FAILED(CompileShaderFromFile(SHADER_PATH VERTEX_SHADER_FILE, 0, "main", "vs_4_0", &VS))) 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))) 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->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), nullptr, &pVS);
dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), nullptr, &pPS); dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), nullptr, &pPS);

2
samples/SimpleTexturedOpenGL/CMakeLists.txt
View File

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

162
samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp
View File

@ -41,7 +41,6 @@
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include <assimp/LogStream.hpp> #include <assimp/LogStream.hpp>
#include "UTFConverter.h"
// The default hard-coded path. Can be overridden by supplying a path through the command line. // 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"; static std::string modelpath = "../../test/models/OBJ/spider.obj";
@ -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 LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f }; GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f };
// the global Assimp scene object // the global Assimp scene object
const aiScene* g_scene = nullptr; const aiScene* g_scene = nullptr;
GLuint scene_list = 0; GLuint scene_list = 0;
@ -83,12 +80,8 @@ GLuint* textureIds; // pointer to texture Array
// Create an instance of the Importer class // Create an instance of the Importer class
Assimp::Importer importer; 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; Assimp::Logger::LogSeverity severity = Assimp::Logger::VERBOSE;
// Create a logger instance for Console Output // Create a logger instance for Console Output
@ -101,62 +94,52 @@ void createAILogger()
Assimp::DefaultLogger::get()->info("this is my info-call"); Assimp::DefaultLogger::get()->info("this is my info-call");
} }
void destroyAILogger() void destroyAILogger() {
{
// Kill it after the work is done
Assimp::DefaultLogger::kill(); 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()); 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); Assimp::DefaultLogger::get()->debug(logString);
} }
bool Import3DFromFile( const std::string& pFile) bool Import3DFromFile( const std::string &filename) {
{
// Check if file exists // 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);
else ::MessageBox(nullptr, targetMessage.c_str(), L"Error", MB_OK | MB_ICONEXCLAMATION);
{
MessageBox(nullptr, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
logInfo(importer.GetErrorString()); logInfo(importer.GetErrorString());
return false; return false;
} }
g_scene = importer.ReadFile(pFile, aiProcessPreset_TargetRealtime_Quality); fin.close();
g_scene = importer.ReadFile(filename, aiProcessPreset_TargetRealtime_Quality);
// If the import failed, report it // If the import failed, report it
if(!g_scene) if (g_scene == nullptr) {
{
logInfo( importer.GetErrorString()); logInfo( importer.GetErrorString());
return false; return false;
} }
// Now we can access the file's contents. // 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 // We're done. Everything will be cleaned up by the importer destructor
return true; return true;
} }
// Resize And Initialize The GL Window // Resize And Initialize The GL Window
void ReSizeGLScene(GLsizei width, GLsizei height) void ReSizeGLScene(GLsizei width, GLsizei height) {
{
// Prevent A Divide By Zero By // Prevent A Divide By Zero By
if (height==0) if (height == 0) {
{
// Making Height Equal One // Making Height Equal One
height=1; 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("\\/"); size_t pos = path.find_last_of("\\/");
return (std::string::npos == pos) ? "" : path.substr(0, pos + 1); 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; delete[] textureIds;
textureIds = nullptr; textureIds = nullptr;
} }
} }
int LoadGLTextures(const aiScene* scene) int LoadGLTextures(const aiScene* scene) {
{
freeTextureIds(); 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 */ /* getTexture Filenames and Numb of Textures */
for (unsigned int m=0; m<scene->mNumMaterials; m++) for (unsigned int m=0; m<scene->mNumMaterials; m++)
@ -230,14 +196,6 @@ int LoadGLTextures(const aiScene* scene)
const size_t numTextures = textureIdMap.size(); 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 */ /* create and fill array with GL texture ids */
textureIds = new GLuint[numTextures]; textureIds = new GLuint[numTextures];
glGenTextures(static_cast<GLsizei>(numTextures), textureIds); /* Texture name generation */ glGenTextures(static_cast<GLsizei>(numTextures), textureIds); /* Texture name generation */
@ -248,29 +206,17 @@ int LoadGLTextures(const aiScene* scene)
std::string basepath = getBasePath(modelpath); std::string basepath = getBasePath(modelpath);
for (size_t i=0; i<numTextures; i++) for (size_t i=0; i<numTextures; i++)
{ {
//save IL image ID
std::string filename = (*itr).first; // get filename std::string filename = (*itr).first; // get filename
(*itr).second = &textureIds[i]; // save texture id for filename in map (*itr).second = &textureIds[i]; // save texture id for filename in map
itr++; // next texture itr++; // next texture
//ilBindImage(imageIds[i]); /* Binding of DevIL image name */
std::string fileloc = basepath + filename; /* Loading of image */ std::string fileloc = basepath + filename; /* Loading of image */
//success = ilLoadImage(fileloc.c_str());
int x, y, n; int x, y, n;
unsigned char *data = stbi_load(fileloc.c_str(), &x, &y, &n, STBI_rgb_alpha); unsigned char *data = stbi_load(fileloc.c_str(), &x, &y, &n, STBI_rgb_alpha);
if (nullptr != data ) 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 // Binding of texture name
glBindTexture(GL_TEXTURE_2D, textureIds[i]); glBindTexture(GL_TEXTURE_2D, textureIds[i]);
// redefine standard texture values // redefine standard texture values
@ -287,19 +233,18 @@ int LoadGLTextures(const aiScene* scene)
glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 ); glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 ); glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 );
stbi_image_free(data); stbi_image_free(data);
} } else {
else
{
/* Error occurred */ /* Error occurred */
MessageBox(nullptr, UTFConverter("Couldn't load Image: " + fileloc).c_wstr(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); const std::string message = "Couldn't load Image: " + fileloc;
std::wstring targetMessage;
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; return TRUE;
} }
@ -312,7 +257,6 @@ int InitGL()
return FALSE; return FALSE;
} }
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH); // Enables Smooth Shading glShadeModel(GL_SMOOTH); // Enables Smooth Shading
glClearColor(1.0f, 1.0f, 1.0f, 0.0f); 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); drawAiScene(g_scene);
//xrot+=0.3f;
yrot += 0.2f; yrot += 0.2f;
//zrot+=0.4f;
return TRUE; // okay return TRUE; // okay
} }
@ -591,8 +533,18 @@ void KillGLWindow() // Properly Kill The Window
GLboolean abortGLInit(const char* abortMessage) 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 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 (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{ {
// If The Mode Fails, Offer Two Options. Quit Or Run In A Window. // 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) 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 AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
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 if (nullptr == (g_hWnd = CreateWindowEx(dwExStyle, // Extended Style For The Window
TEXT("OpenGL"), // Class Name TEXT("OpenGL"), // Class Name
UTFConverter(title).c_wstr(), // Window Title targetMessage.c_str(), // Window Title
WS_CLIPSIBLINGS | // Required Window Style WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN | // Required Window Style WS_CLIPCHILDREN | // Required Window Style
dwStyle, // Selected WIndow Style dwStyle, // Selected WIndow Style
@ -843,7 +803,11 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/, // The instance
if (argv != nullptr && argc > 1) if (argv != nullptr && argc > 1)
{ {
std::wstring modelpathW(argv[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)) if (!Import3DFromFile(modelpath))

6
tools/assimp_view/AnimEvaluator.cpp
View File

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

2
tools/assimp_view/AnimEvaluator.h
View File

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

17
tools/assimp_view/AssetHelper.h
View File

@ -77,6 +77,13 @@ public:
pcScene = NULL; 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 // default vertex data structure
// (even if tangents, bitangents or normals aren't // (even if tangents, bitangents or normals aren't
@ -221,16 +228,8 @@ public:
// Specifies the normal set to be used // Specifies the normal set to be used
unsigned int iNormalSet; 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 } // namespace AssimpView
#endif // !! IG #endif // !! IG

18
tools/assimp_view/Material.cpp
View File

@ -175,18 +175,13 @@ VOID WINAPI FillFunc(D3DXVECTOR4* pOut,
pOut->x = pOut->y = 1.0f; pOut->x = pOut->y = 1.0f;
pOut->z = 0.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->DeleteMaterial(g_pcAsset->apcMeshes[i]);
this->CreateMaterial(g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]); this->CreateMaterial(g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]);
} }
@ -194,14 +189,15 @@ int CMaterialManager::UpdateSpecularMaterials()
} }
return 1; return 1;
} }
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut) int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut) {
{
if (sDefaultTexture) { if (sDefaultTexture) {
sDefaultTexture->AddRef(); sDefaultTexture->AddRef();
*p_ppiOut = sDefaultTexture; *p_ppiOut = sDefaultTexture;
return 1; return 1;
} }
if(FAILED(g_piDevice->CreateTexture( if(FAILED(g_piDevice->CreateTexture(
256, 256,
256, 256,

9
tools/assimp_view/assimp_view.cpp
View File

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

6
tools/assimp_view/assimp_view.h
View File

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