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

Update utf82utf16.

pull/4986/head
Kim Kulling 2023-03-06 19:56:11 +01:00
parent 7916f87404
commit c089f11768
3 changed files with 64 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/assimp/types.h
View File

@ -57,6 +57,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <string.h>
#include <sys/types.h>
#ifdef ASSIMP_USE_HUNTER
#include <utf8.h>
#else
#include "../contrib/utf8cpp/source/utf8.h"
#endif
// Our compile configuration
#include <assimp/defs.h>

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

@ -13,6 +13,8 @@
// Written by IAS. :)
// ---------------------------------------------------------------------------
#include <assimp/types.h>
#include <Windows.h>
#include <shellapi.h>
#include <stdexcept>
@ -21,11 +23,7 @@
#include <dxgi1_2.h>
#include <DirectXMath.h>
#include <d3dcompiler.h>
#ifdef ASSIMP_USE_HUNTER
#include <utf8.h>
#else
#include "../contrib/utf8cpp/source/utf8.h"
#endif
#include "ModelLoader.h"
#include "SafeRelease.hpp"
@ -53,10 +51,10 @@ struct ConstantBuffer {
// ------------------------------------------------------------
// Window Variables
// ------------------------------------------------------------
#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600
static constexpr uint32_t SCREEN_WIDTH = 800;
static constexpr uint32_t SCREEN_HEIGHT = 600;
const char g_szClassName[] = "directxWindowClass";
constexpr char g_szClassName[] = "directxWindowClass";
static std::string g_ModelPath;

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

@ -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
HDC hDC=nullptr; // Private GDI Device Context
HWND g_hWnd=nullptr; // Holds Window Handle
HINSTANCE g_hInstance=nullptr; // Holds The Instance Of The Application
HGLRC hRC = nullptr; // Permanent Rendering Context
HDC hDC = nullptr; // Private GDI Device Context
HWND g_hWnd = nullptr; // Holds Window Handle
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 analyse the import process
//Assimp::Logger::LogSeverity severity = Assimp::Logger::NORMAL;
void createAILogger() {
// Change this line to normal if you not want to analyze the import process
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()
{
// Kill it after the work is done
void destroyAILogger() {
Assimp::DefaultLogger::kill();
}
void logInfo(std::string logString)
{
// Will add message to File with "info" Tag
void logInfo(const std::string &logString) {
Assimp::DefaultLogger::get()->info(logString.c_str());
}
void logDebug(const char* logString)
{
// Will add message to File with "debug" Tag
void logDebug(const char* logString) {
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());
if(!fin.fail())
{
fin.close();
}
else
{
MessageBox(nullptr, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
logInfo( importer.GetErrorString());
std::ifstream fin(filename.c_str());
if(fin.fail()) {
std::string message = "Couldn't open file: " + filename;
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;
}
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(!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()
{
textureIdMap.clear(); //no need to delete pointers in it manually here. (Pointers point to textureIds deleted in next step)
void freeTextureIds() {
// 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;
/* 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");
if (scene->HasTextures())
return 1;
/* 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
@ -291,15 +237,12 @@ int LoadGLTextures(const aiScene* scene)
else
{
/* 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;
utf8::utf8to16(message.c_str(), message.c_str() + message.size(), back_inserter(targetMessage));
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 +255,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 +479,7 @@ int DrawGLScene() //Here's where we do all the drawing
drawAiScene(g_scene);
//xrot+=0.3f;
yrot+=0.2f;
//zrot+=0.4f;
yrot += 0.2f;
return TRUE; // okay
}
@ -591,8 +531,13 @@ void KillGLWindow() // Properly Kill The Window
GLboolean abortGLInit(const char* abortMessage)
{
KillGLWindow(); // Reset Display
MessageBox(nullptr, UTFConverter(abortMessage).c_wstr(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION);
// Reset Display
KillGLWindow();
const std::string message = abortMessage;
std::wstring targetMessage;
utf8::utf8to16(message.c_str(), message.c_str() + message.size(), back_inserter(targetMessage));
MessageBox(nullptr, targetMessage.c_str(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION);
return FALSE; // quit and return False
}
@ -669,9 +614,13 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
const std::string message = title;
std::wstring targetMessage;
utf8::utf8to16(message.c_str(), message.c_str() + message.size(), back_inserter(targetMessage));
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 +792,7 @@ int WINAPI WinMain( HINSTANCE /*hInstance*/, // The instance
if (argv != nullptr && argc > 1)
{
std::wstring modelpathW(argv[1]);
modelpath = UTFConverter(modelpathW).str();
utf8::utf16to8(modelpathW.c_str(), modelpathW.c_str() + modelpathW.size(), back_inserter(modelpath));
}
if (!Import3DFromFile(modelpath))