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

Merge branch 'master' into draco_1.5.6

pull/4978/head
Kim Kulling 2023-03-08 13:52:38 +01:00 committed by GitHub
parent c305b50f13 366243f7ef
commit 980e156251
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 158 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.github/workflows/sanitizer.yml vendored
View File

@ -57,3 +57,13 @@ jobs:
- name: test
run: cd build/bin && ./unit
shell: bash
job3:
name: printf-sanitizer
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: run scan_printf script
run: ./scripts/scan_printf.sh
shell: bash

4
code/AssetLib/FBX/FBXConverter.cpp
View File

@ -873,8 +873,12 @@ void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) {
data->Set(index++, prop.first, interpretedBool->Value());
} else if (const TypedProperty<int> *interpretedInt = prop.second->As<TypedProperty<int>>()) {
data->Set(index++, prop.first, interpretedInt->Value());
} else if (const TypedProperty<uint32_t> *interpretedUInt = prop.second->As<TypedProperty<uint32_t>>()) {
data->Set(index++, prop.first, interpretedUInt->Value());
} else if (const TypedProperty<uint64_t> *interpretedUint64 = prop.second->As<TypedProperty<uint64_t>>()) {
data->Set(index++, prop.first, interpretedUint64->Value());
} else if (const TypedProperty<int64_t> *interpretedint64 = prop.second->As<TypedProperty<int64_t>>()) {
data->Set(index++, prop.first, interpretedint64->Value());
} else if (const TypedProperty<float> *interpretedFloat = prop.second->As<TypedProperty<float>>()) {
data->Set(index++, prop.first, interpretedFloat->Value());
} else if (const TypedProperty<std::string> *interpretedString = prop.second->As<TypedProperty<std::string>>()) {

2
code/AssetLib/Ogre/OgreXmlSerializer.cpp
View File

@ -490,7 +490,7 @@ bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *me
OgreXmlSerializer serializer(xmlParser.get());
XmlNode root = xmlParser->getRootNode();
if (std::string(root.name()) != nnSkeleton) {
printf("\nSkeleton is not a valid root: %s\n", root.name());
ASSIMP_LOG_VERBOSE_DEBUG("nSkeleton is not a valid root: ", root.name(), ".");
for (auto &a : root.children()) {
if (std::string(a.name()) == nnSkeleton) {
root = a;

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

1
include/assimp/MemoryIOWrapper.h
View File

@ -150,7 +150,6 @@ public:
// -------------------------------------------------------------------
/// @brief Tests for the existence of a file at the given path.
bool Exists(const char* pFile) const override {
printf("Exists\n");
if (0 == strncmp( pFile, AI_MEMORYIO_MAGIC_FILENAME, AI_MEMORYIO_MAGIC_FILENAME_LENGTH ) ) {
return true;
}

6
include/assimp/types.h
View File

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

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/main.cpp
SimpleTexturedDirectx11/SafeRelease.hpp
${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
)
TARGET_USE_COMMON_OUTPUT_DIRECTORY(assimp_simpletextureddirectx11)

23
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,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
#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;
@ -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);

2
samples/SimpleTexturedOpenGL/CMakeLists.txt
View File

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

178
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
@ -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 */
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;
}
@ -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;
//zrot+=0.4f;
yrot += 0.2f;
return TRUE; // okay
}
@ -591,8 +533,18 @@ 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;
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
{

13
scripts/scan_printf.sh 100755
View File

@ -0,0 +1,13 @@
#!/bin/bash
grep \
--include=\*.{c,cpp,h} \
--exclude={pstdint,m3d}.h \
-rnw include code \
-e '^\s*printf'
if [ $? -eq 0 ]; then
echo "Debug statement(s) detected. Please uncomment (using single-line comment), remove, or manually add to exclude filter, if appropriate"
exit 1
fi

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));
}
// ------------------------------------------------------------------------------------------------
// Destructor.
AnimEvaluator::~AnimEvaluator() {
// empty
}
// ------------------------------------------------------------------------------------------------
// Evaluates the animation tracks for a given time stamp.
void AnimEvaluator::Evaluate(double pTime) {

2
tools/assimp_view/AnimEvaluator.h
View File

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

17
tools/assimp_view/AssetHelper.h
View File

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

20
tools/assimp_view/Material.cpp
View File

@ -175,33 +175,29 @@ VOID WINAPI FillFunc(D3DXVECTOR4* pOut,
pOut->x = pOut->y = 1.0f;
pOut->z = 0.0f;
}
return;
}
//-------------------------------------------------------------------------------
int CMaterialManager::UpdateSpecularMaterials()
{
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)
{
int CMaterialManager::UpdateSpecularMaterials() {
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) {
this->DeleteMaterial(g_pcAsset->apcMeshes[i]);
this->CreateMaterial(g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]);
}
}
}
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,

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
// smart progress bar
//-------------------------------------------------------------------------------
DWORD WINAPI LoadThreadProc(LPVOID lpParameter) {
UNREFERENCED_PARAMETER(lpParameter);
DWORD WINAPI LoadThreadProc(LPVOID) {
// 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 *
numIndices,
if (FAILED(g_piDevice->CreateIndexBuffer(2 * numIndices,
D3DUSAGE_WRITEONLY | dwUsage,
D3DFMT_INDEX16,
D3DPOOL_DEFAULT,

6
tools/assimp_view/assimp_view.h
View File

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