Merge branch 'master' into master

pull/3111/head
György Straub 2020-04-12 15:58:25 +01:00 committed by GitHub
commit e4ceccb42d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
46 changed files with 1481 additions and 1017 deletions

View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -43,7 +41,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Implementation of the 3ds importer class */ /** @file Implementation of the 3ds importer class */
#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
// internal headers // internal headers

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -121,8 +121,9 @@ M3DWrapper::~M3DWrapper() {
void M3DWrapper::reset() { void M3DWrapper::reset() {
ClearSave(); ClearSave();
if (m3d_) if (m3d_) {
m3d_free(m3d_); m3d_free(m3d_);
}
m3d_ = nullptr; m3d_ = nullptr;
} }

View File

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

View File

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

View File

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

View File

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

View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -43,17 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Implementation of the Terragen importer class */ /** @file Implementation of the Terragen importer class */
#ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
#include "TerragenLoader.h" #include "TerragenLoader.h"
#include <assimp/StreamReader.h> #include <assimp/StreamReader.h>
#include <assimp/Importer.hpp> #include <assimp/importerdesc.h>
#include <assimp/IOSystem.hpp>
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include <assimp/importerdesc.h> #include <assimp/IOSystem.hpp>
#include <assimp/Importer.hpp>
using namespace Assimp; using namespace Assimp;
@ -72,19 +68,16 @@ static const aiImporterDesc desc = {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer // Constructor to be privately used by Importer
TerragenImporter::TerragenImporter() TerragenImporter::TerragenImporter() :
: configComputeUVs (false) configComputeUVs(false) {}
{}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Destructor, private as well // Destructor, private as well
TerragenImporter::~TerragenImporter() TerragenImporter::~TerragenImporter() {}
{}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file. // Returns whether the class can handle the format of the given file.
bool TerragenImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
{
// check file extension // check file extension
std::string extension = GetExtension(pFile); std::string extension = GetExtension(pFile);
@ -105,15 +98,13 @@ bool TerragenImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Build a string of all file extensions supported // Build a string of all file extensions supported
const aiImporterDesc* TerragenImporter::GetInfo () const const aiImporterDesc *TerragenImporter::GetInfo() const {
{
return &desc; return &desc;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Setup import properties // Setup import properties
void TerragenImporter::SetupProperties(const Importer* pImp) void TerragenImporter::SetupProperties(const Importer *pImp) {
{
// AI_CONFIG_IMPORT_TER_MAKE_UVS // AI_CONFIG_IMPORT_TER_MAKE_UVS
configComputeUVs = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS, 0)); configComputeUVs = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS, 0));
} }
@ -121,8 +112,7 @@ void TerragenImporter::SetupProperties(const Importer* pImp)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void TerragenImporter::InternReadFile(const std::string &pFile, void TerragenImporter::InternReadFile(const std::string &pFile,
aiScene* pScene, IOSystem* pIOHandler) aiScene *pScene, IOSystem *pIOHandler) {
{
IOStream *file = pIOHandler->Open(pFile, "rb"); IOStream *file = pIOHandler->Open(pFile, "rb");
// Check whether we can read from the file // Check whether we can read from the file
@ -151,8 +141,7 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
// Now read all chunks until we're finished or an EOF marker is encountered // Now read all chunks until we're finished or an EOF marker is encountered
reader.IncPtr(16); reader.IncPtr(16);
while (reader.GetRemainingSize() >= 4) while (reader.GetRemainingSize() >= 4) {
{
const char *head = (const char *)reader.GetPtr(); const char *head = (const char *)reader.GetPtr();
reader.IncPtr(4); reader.IncPtr(4);
@ -161,42 +150,35 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
break; break;
// Number of x-data points // Number of x-data points
if (!::strncmp(head,AI_TERR_CHUNK_XPTS,4)) if (!::strncmp(head, AI_TERR_CHUNK_XPTS, 4)) {
{
x = (uint16_t)reader.GetI2(); x = (uint16_t)reader.GetI2();
} }
// Number of y-data points // Number of y-data points
else if (!::strncmp(head,AI_TERR_CHUNK_YPTS,4)) else if (!::strncmp(head, AI_TERR_CHUNK_YPTS, 4)) {
{
y = (uint16_t)reader.GetI2(); y = (uint16_t)reader.GetI2();
} }
// Squared terrains width-1. // Squared terrains width-1.
else if (!::strncmp(head,AI_TERR_CHUNK_SIZE,4)) else if (!::strncmp(head, AI_TERR_CHUNK_SIZE, 4)) {
{
x = y = (uint16_t)reader.GetI2() + 1; x = y = (uint16_t)reader.GetI2() + 1;
} }
// terrain scaling // terrain scaling
else if (!::strncmp(head,AI_TERR_CHUNK_SCAL,4)) else if (!::strncmp(head, AI_TERR_CHUNK_SCAL, 4)) {
{
root->mTransformation.a1 = reader.GetF4(); root->mTransformation.a1 = reader.GetF4();
root->mTransformation.b2 = reader.GetF4(); root->mTransformation.b2 = reader.GetF4();
root->mTransformation.c3 = reader.GetF4(); root->mTransformation.c3 = reader.GetF4();
} }
// mapping == 1: earth radius // mapping == 1: earth radius
else if (!::strncmp(head,AI_TERR_CHUNK_CRAD,4)) else if (!::strncmp(head, AI_TERR_CHUNK_CRAD, 4)) {
{
reader.GetF4(); reader.GetF4();
} }
// mapping mode // mapping mode
else if (!::strncmp(head,AI_TERR_CHUNK_CRVM,4)) else if (!::strncmp(head, AI_TERR_CHUNK_CRVM, 4)) {
{
mode = reader.GetI1(); mode = reader.GetI1();
if (0 != mode) if (0 != mode)
ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned"); ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned");
} }
// actual terrain data // actual terrain data
else if (!::strncmp(head,AI_TERR_CHUNK_ALTW,4)) else if (!::strncmp(head, AI_TERR_CHUNK_ALTW, 4)) {
{
float hscale = (float)reader.GetI2() / 65536; float hscale = (float)reader.GetI2() / 65536;
float bheight = (float)reader.GetI2(); float bheight = (float)reader.GetI2();
@ -247,8 +229,10 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
// make indices // make indices
f->mIndices = new unsigned int[f->mNumIndices = 4]; f->mIndices = new unsigned int[f->mNumIndices = 4];
for (unsigned int i = 0; i < 4;++i) for (unsigned int i = 0; i < 4; ++i) {
f->mIndices[i] = t++; f->mIndices[i] = t;
t++;
}
} }
} }

View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -69,21 +68,17 @@ namespace Assimp {
* The loader is basing on the information found here: * The loader is basing on the information found here:
* http://www.planetside.co.uk/terragen/dev/tgterrain.html#chunks * http://www.planetside.co.uk/terragen/dev/tgterrain.html#chunks
*/ */
class TerragenImporter : public BaseImporter class TerragenImporter : public BaseImporter {
{
public: public:
TerragenImporter(); TerragenImporter();
~TerragenImporter(); ~TerragenImporter();
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
bool checkSig) const; bool checkSig) const;
protected: protected:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
const aiImporterDesc *GetInfo() const; const aiImporterDesc *GetInfo() const;
@ -95,7 +90,6 @@ protected:
void SetupProperties(const Importer *pImp); void SetupProperties(const Importer *pImp);
private: private:
bool configComputeUVs; bool configComputeUVs;
}; //! class TerragenImporter }; //! class TerragenImporter

View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -48,26 +46,112 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* http://local.wasp.uwa.edu.au/~pbourke/dataformats/unreal/ * http://local.wasp.uwa.edu.au/~pbourke/dataformats/unreal/
*/ */
#ifndef ASSIMP_BUILD_NO_3D_IMPORTER #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
#include "Unreal/UnrealLoader.h" #include "Unreal/UnrealLoader.h"
#include "PostProcessing/ConvertToLHProcess.h" #include "PostProcessing/ConvertToLHProcess.h"
#include <assimp/StreamReader.h>
#include <assimp/ParsingUtils.h> #include <assimp/ParsingUtils.h>
#include <assimp/StreamReader.h>
#include <assimp/fast_atof.h> #include <assimp/fast_atof.h>
#include <assimp/Importer.hpp> #include <assimp/importerdesc.h>
#include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
#include <assimp/scene.h> #include <assimp/Importer.hpp>
#include <assimp/importerdesc.h>
#include <stdint.h>
#include <memory> #include <memory>
using namespace Assimp; using namespace Assimp;
namespace Unreal {
/*
0 = Normal one-sided
1 = Normal two-sided
2 = Translucent two-sided
3 = Masked two-sided
4 = Modulation blended two-sided
8 = Placeholder triangle for weapon positioning (invisible)
*/
enum MeshFlags {
MF_NORMAL_OS = 0,
MF_NORMAL_TS = 1,
MF_NORMAL_TRANS_TS = 2,
MF_NORMAL_MASKED_TS = 3,
MF_NORMAL_MOD_TS = 4,
MF_WEAPON_PLACEHOLDER = 8
};
// a single triangle
struct Triangle {
uint16_t mVertex[3]; // Vertex indices
char mType; // James' Mesh Type
char mColor; // Color for flat and Gourand Shaded
unsigned char mTex[3][2]; // Texture UV coordinates
unsigned char mTextureNum; // Source texture offset
char mFlags; // Unreal Mesh Flags (unused)
unsigned int matIndex;
};
// temporary representation for a material
struct TempMat {
TempMat() :
type(MF_NORMAL_OS), tex(), numFaces(0) {}
explicit TempMat(const Triangle &in) :
type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {}
// type of mesh
Unreal::MeshFlags type;
// index of texture
unsigned int tex;
// number of faces using us
unsigned int numFaces;
// for std::find
bool operator==(const TempMat &o) {
return (tex == o.tex && type == o.type);
}
};
struct Vertex {
int32_t X : 11;
int32_t Y : 11;
int32_t Z : 10;
};
// UNREAL vertex compression
inline void CompressVertex(const aiVector3D &v, uint32_t &out) {
union {
Vertex n;
int32_t t;
};
t = 0;
n.X = (int32_t)v.x;
n.Y = (int32_t)v.y;
n.Z = (int32_t)v.z;
::memcpy(&out, &t, sizeof(int32_t));
}
// UNREAL vertex decompression
inline void DecompressVertex(aiVector3D &v, int32_t in) {
union {
Vertex n;
int32_t i;
};
i = in;
v.x = (float)n.X;
v.y = (float)n.Y;
v.z = (float)n.Z;
}
} // end namespace Unreal
static const aiImporterDesc desc = { static const aiImporterDesc desc = {
"Unreal Mesh Importer", "Unreal Mesh Importer",
"", "",
@ -81,54 +165,46 @@ static const aiImporterDesc desc = {
"3d uc" "3d uc"
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer // Constructor to be privately used by Importer
UnrealImporter::UnrealImporter() UnrealImporter::UnrealImporter() :
: configFrameID (0) mConfigFrameID(0), mConfigHandleFlags(true) {}
, configHandleFlags (true)
{}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Destructor, private as well // Destructor, private as well
UnrealImporter::~UnrealImporter() UnrealImporter::~UnrealImporter() {}
{}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file. // Returns whether the class can handle the format of the given file.
bool UnrealImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const bool UnrealImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
{
return SimpleExtensionCheck(pFile, "3d", "uc"); return SimpleExtensionCheck(pFile, "3d", "uc");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Build a string of all file extensions supported // Build a string of all file extensions supported
const aiImporterDesc* UnrealImporter::GetInfo () const const aiImporterDesc *UnrealImporter::GetInfo() const {
{
return &desc; return &desc;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Setup configuration properties for the loader // Setup configuration properties for the loader
void UnrealImporter::SetupProperties(const Importer* pImp) void UnrealImporter::SetupProperties(const Importer *pImp) {
{
// The // The
// AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the // AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the
// AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME,-1); mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME, -1);
if(static_cast<unsigned int>(-1) == configFrameID) { if (static_cast<unsigned int>(-1) == mConfigFrameID) {
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0); mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
} }
// AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true // AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true
configHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS,1)); mConfigHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, 1));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void UnrealImporter::InternReadFile(const std::string &pFile, void UnrealImporter::InternReadFile(const std::string &pFile,
aiScene* pScene, IOSystem* pIOHandler) aiScene *pScene, IOSystem *pIOHandler) {
{
// For any of the 3 files being passed get the three correct paths // For any of the 3 files being passed get the three correct paths
// First of all, determine file extension // First of all, determine file extension
std::string::size_type pos = pFile.find_last_of('.'); std::string::size_type pos = pFile.find_last_of('.');
@ -143,8 +219,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
throw DeadlyImportError("UNREAL: Unexpected naming scheme"); throw DeadlyImportError("UNREAL: Unexpected naming scheme");
} }
extension = pFile.substr(0, pos); extension = pFile.substr(0, pos);
} } else {
else {
extension = pFile.substr(0, pos); extension = pFile.substr(0, pos);
} }
@ -186,7 +261,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
tri.mType = d_reader.GetI1(); tri.mType = d_reader.GetI1();
// handle mesh flagss? // handle mesh flagss?
if (configHandleFlags) if (mConfigHandleFlags)
tri.mType = Unreal::MF_NORMAL_OS; tri.mType = Unreal::MF_NORMAL_OS;
else { else {
// ignore MOD and MASKED for the moment, treat them as two-sided // ignore MOD and MASKED for the moment, treat them as two-sided
@ -211,7 +286,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
// read number of frames // read number of frames
const uint32_t numFrames = a_reader.GetI2(); const uint32_t numFrames = a_reader.GetI2();
if (configFrameID >= numFrames) { if (mConfigFrameID >= numFrames) {
throw DeadlyImportError("UNREAL: The requested frame does not exist"); throw DeadlyImportError("UNREAL: The requested frame does not exist");
} }
@ -220,7 +295,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
throw DeadlyImportError("UNREAL: Unexpected aniv file length"); throw DeadlyImportError("UNREAL: Unexpected aniv file length");
// skip to our frame // skip to our frame
a_reader.IncPtr(configFrameID *numVert*4); a_reader.IncPtr(mConfigFrameID * numVert * 4);
// collect vertices // collect vertices
std::vector<aiVector3D> vertices(numVert); std::vector<aiVector3D> vertices(numVert);
@ -261,12 +336,13 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
for (; !IsLineEnd(*data); ++data) { for (; !IsLineEnd(*data); ++data) {
if (!::ASSIMP_strincmp(data, "NAME=", 5)) { if (!::ASSIMP_strincmp(data, "NAME=", 5)) {
const char *d = data += 5; const char *d = data += 5;
for (;!IsSpaceOrNewLine(*data);++data); for (; !IsSpaceOrNewLine(*data); ++data)
;
me.first = std::string(d, (size_t)(data - d)); me.first = std::string(d, (size_t)(data - d));
} } else if (!::ASSIMP_strincmp(data, "FILE=", 5)) {
else if (!::ASSIMP_strincmp(data,"FILE=",5)) {
const char *d = data += 5; const char *d = data += 5;
for (;!IsSpaceOrNewLine(*data);++data); for (; !IsSpaceOrNewLine(*data); ++data)
;
me.second = std::string(d, (size_t)(data - d)); me.second = std::string(d, (size_t)(data - d));
} }
} }
@ -288,11 +364,11 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
if (!::ASSIMP_strincmp(data, "NUM=", 4)) { if (!::ASSIMP_strincmp(data, "NUM=", 4)) {
data += 4; data += 4;
me.first = strtoul10(data, &data); me.first = strtoul10(data, &data);
} } else if (!::ASSIMP_strincmp(data, "TEXTURE=", 8)) {
else if (!::ASSIMP_strincmp(data,"TEXTURE=",8)) {
data += 8; data += 8;
const char *d = data; const char *d = data;
for (;!IsSpaceOrNewLine(*data);++data); for (; !IsSpaceOrNewLine(*data); ++data)
;
me.second = std::string(d, (size_t)(data - d)); me.second = std::string(d, (size_t)(data - d));
// try to find matching path names, doesn't care if we don't find them // try to find matching path names, doesn't care if we don't find them
@ -305,17 +381,14 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
} }
} }
} }
} } else if (TokenMatchI(data, "SCALE", 5)) {
else if (TokenMatchI(data,"SCALE",5)) {
for (; !IsLineEnd(*data); ++data) { for (; !IsLineEnd(*data); ++data) {
if (data[0] == 'X' && data[1] == '=') { if (data[0] == 'X' && data[1] == '=') {
data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.a1); data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.a1);
} } else if (data[0] == 'Y' && data[1] == '=') {
else if (data[0] == 'Y' && data[1] == '=') {
data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.b2); data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.b2);
} } else if (data[0] == 'Z' && data[1] == '=') {
else if (data[0] == 'Z' && data[1] == '=') {
data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.c3); data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.c3);
} }
} }
@ -323,8 +396,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
} }
} }
} }
} } else {
else {
ASSIMP_LOG_ERROR("Unable to open .uc file"); ASSIMP_LOG_ERROR("Unable to open .uc file");
} }
@ -342,8 +414,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
materials.push_back(mat); materials.push_back(mat);
++pScene->mNumMeshes; ++pScene->mNumMeshes;
} } else {
else {
tri.matIndex = static_cast<unsigned int>(nt - materials.begin()); tri.matIndex = static_cast<unsigned int>(nt - materials.begin());
++nt->numFaces; ++nt->numFaces;
} }
@ -385,16 +456,16 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
const int twosided = 1; const int twosided = 1;
mat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED); mat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
::strcat(s.data, "ts_"); ::strcat(s.data, "ts_");
} } else
else ::strcat(s.data,"os_"); ::strcat(s.data, "os_");
// make TRANS faces 90% opaque that RemRedundantMaterials won't catch us // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us
if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) { if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) {
const float opac = 0.9f; const float opac = 0.9f;
mat->AddProperty(&opac, 1, AI_MATKEY_OPACITY); mat->AddProperty(&opac, 1, AI_MATKEY_OPACITY);
::strcat(s.data, "tran_"); ::strcat(s.data, "tran_");
} } else
else ::strcat(s.data,"opaq_"); ::strcat(s.data, "opaq_");
// a special name for the weapon attachment point // a special name for the weapon attachment point
if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) { if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) {
@ -404,7 +475,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
// set color and name // set color and name
mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE); mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
s.length = (ai_uint32)::strlen(s.data); s.length = static_cast<ai_uint32>(::strlen(s.data));
mat->AddProperty(&s, AI_MATKEY_NAME); mat->AddProperty(&s, AI_MATKEY_NAME);
// set texture, if any // set texture, if any

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -52,10 +50,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#include <assimp/IOStream.hpp>
#include <assimp/Defines.h>
#include <assimp/ByteSwapper.h> #include <assimp/ByteSwapper.h>
#include <assimp/Defines.h>
#include <assimp/Exceptional.h> #include <assimp/Exceptional.h>
#include <assimp/IOStream.hpp>
#include <memory> #include <memory>
@ -74,10 +72,8 @@ namespace Assimp {
template <bool SwapEndianess = false, bool RuntimeSwitch = false> template <bool SwapEndianess = false, bool RuntimeSwitch = false>
class StreamReader { class StreamReader {
public: public:
// FIXME: use these data types throughout the whole library, using diff = size_t;
// then change them to 64 bit values :-) using pos = size_t;
using diff = int;
using pos = unsigned int;
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Construction from a given stream with a well-defined endianness. /** Construction from a given stream with a well-defined endianness.
@ -91,39 +87,44 @@ public:
* stream is in little endian byte order. Otherwise the * stream is in little endian byte order. Otherwise the
* endianness information is contained in the @c SwapEndianess * endianness information is contained in the @c SwapEndianess
* template parameter and this parameter is meaningless. */ * template parameter and this parameter is meaningless. */
StreamReader(std::shared_ptr<IOStream> stream, bool le = false) StreamReader(std::shared_ptr<IOStream> stream, bool le = false) :
: stream(stream) mStream(stream),
, le(le) mBuffer(nullptr),
{ mCurrent(nullptr),
mEnd(nullptr),
mLimit(nullptr),
mLe(le) {
ai_assert(stream); ai_assert(stream);
InternBegin(); InternBegin();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
StreamReader(IOStream* stream, bool le = false) StreamReader(IOStream *stream, bool le = false) :
: stream(std::shared_ptr<IOStream>(stream)) mStream(std::shared_ptr<IOStream>(stream)),
, le(le) mBuffer(nullptr),
{ mCurrent(nullptr),
ai_assert(stream); mEnd(nullptr),
mLimit(nullptr),
mLe(le) {
ai_assert(nullptr != stream);
InternBegin(); InternBegin();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
~StreamReader() { ~StreamReader() {
delete[] buffer; delete[] mBuffer;
} }
// deprecated, use overloaded operator>> instead // deprecated, use overloaded operator>> instead
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Read a float from the stream */ /// Read a float from the stream.
float GetF4() float GetF4() {
{
return Get<float>(); return Get<float>();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Read a double from the stream */ /// Read a double from the stream.
double GetF8() { double GetF8() {
return Get<double>(); return Get<double>();
} }
@ -159,42 +160,42 @@ public:
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Read a unsigned 8 bit integer from the stream */ /// Read a unsigned 8 bit integer from the stream
uint8_t GetU1() { uint8_t GetU1() {
return Get<uint8_t>(); return Get<uint8_t>();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Read an unsigned 32 bit integer from the stream */ /// Read an unsigned 32 bit integer from the stream
uint32_t GetU4() { uint32_t GetU4() {
return Get<uint32_t>(); return Get<uint32_t>();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Read a unsigned 64 bit integer from the stream */ /// Read a unsigned 64 bit integer from the stream
uint64_t GetU8() { uint64_t GetU8() {
return Get<uint64_t>(); return Get<uint64_t>();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Get the remaining stream size (to the end of the stream) */ /// Get the remaining stream size (to the end of the stream)
unsigned int GetRemainingSize() const { size_t GetRemainingSize() const {
return (unsigned int)(end - current); return (unsigned int)(mEnd - mCurrent);
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Get the remaining stream size (to the current read limit). The /** Get the remaining stream size (to the current read limit). The
* return value is the remaining size of the stream if no custom * return value is the remaining size of the stream if no custom
* read limit has been set. */ * read limit has been set. */
unsigned int GetRemainingSizeToLimit() const { size_t GetRemainingSizeToLimit() const {
return (unsigned int)(limit - current); return (unsigned int)(mLimit - mCurrent);
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Increase the file pointer (relative seeking) */ /** Increase the file pointer (relative seeking) */
void IncPtr(intptr_t plus) { void IncPtr(intptr_t plus) {
current += plus; mCurrent += plus;
if (current > limit) { if (mCurrent > mLimit) {
throw DeadlyImportError("End of file or read limit was reached"); throw DeadlyImportError("End of file or read limit was reached");
} }
} }
@ -202,7 +203,7 @@ public:
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Get the current file pointer */ /** Get the current file pointer */
int8_t *GetPtr() const { int8_t *GetPtr() const {
return current; return mCurrent;
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -212,8 +213,8 @@ public:
* @param p The new pointer, which is validated against the size * @param p The new pointer, which is validated against the size
* limit and buffer boundaries. */ * limit and buffer boundaries. */
void SetPtr(int8_t *p) { void SetPtr(int8_t *p) {
current = p; mCurrent = p;
if (current > limit || current < buffer) { if (mCurrent > mLimit || mCurrent < mBuffer) {
throw DeadlyImportError("End of file or read limit was reached"); throw DeadlyImportError("End of file or read limit was reached");
} }
} }
@ -229,14 +230,13 @@ public:
::memcpy(out, ur, bytes); ::memcpy(out, ur, bytes);
} }
// --------------------------------------------------------------------- /// @brief Get the current offset from the beginning of the file
/** Get the current offset from the beginning of the file */
int GetCurrentPos() const { int GetCurrentPos() const {
return (unsigned int)(current - buffer); return (unsigned int)(mCurrent - mBuffer);
} }
void SetCurrentPos(size_t pos) { void SetCurrentPos(size_t pos) {
SetPtr(buffer + pos); SetPtr(mBuffer + pos);
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -249,12 +249,12 @@ public:
unsigned int SetReadLimit(unsigned int _limit) { unsigned int SetReadLimit(unsigned int _limit) {
unsigned int prev = GetReadLimit(); unsigned int prev = GetReadLimit();
if (UINT_MAX == _limit) { if (UINT_MAX == _limit) {
limit = end; mLimit = mEnd;
return prev; return prev;
} }
limit = buffer + _limit; mLimit = mBuffer + _limit;
if (limit > end) { if (mLimit > mEnd) {
throw DeadlyImportError("StreamReader: Invalid read limit"); throw DeadlyImportError("StreamReader: Invalid read limit");
} }
return prev; return prev;
@ -264,14 +264,14 @@ public:
/** Get the current read limit in bytes. Reading over this limit /** Get the current read limit in bytes. Reading over this limit
* accidentally raises an exception. */ * accidentally raises an exception. */
unsigned int GetReadLimit() const { unsigned int GetReadLimit() const {
return (unsigned int)(limit - buffer); return (unsigned int)(mLimit - mBuffer);
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** Skip to the read limit in bytes. Reading over this limit /** Skip to the read limit in bytes. Reading over this limit
* accidentally raises an exception. */ * accidentally raises an exception. */
void SkipToReadLimit() { void SkipToReadLimit() {
current = limit; mCurrent = mLimit;
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -286,14 +286,14 @@ public:
/** Generic read method. ByteSwap::Swap(T*) *must* be defined */ /** Generic read method. ByteSwap::Swap(T*) *must* be defined */
template <typename T> template <typename T>
T Get() { T Get() {
if ( current + sizeof(T) > limit) { if (mCurrent + sizeof(T) > mLimit) {
throw DeadlyImportError("End of file or stream limit was reached"); throw DeadlyImportError("End of file or stream limit was reached");
} }
T f; T f;
::memcpy (&f, current, sizeof(T)); ::memcpy(&f, mCurrent, sizeof(T));
Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le); Intern::Getter<SwapEndianess, T, RuntimeSwitch>()(&f, mLe);
current += sizeof(T); mCurrent += sizeof(T);
return f; return f;
} }
@ -301,31 +301,29 @@ public:
private: private:
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
void InternBegin() { void InternBegin() {
if (!stream) { if (nullptr == mStream) {
// in case someone wonders: StreamReader is frequently invoked with
// no prior validation whether the input stream is valid. Since
// no one bothers changing the error message, this message here
// is passed down to the caller and 'unable to open file'
// simply describes best what happened.
throw DeadlyImportError("StreamReader: Unable to open file"); throw DeadlyImportError("StreamReader: Unable to open file");
} }
const size_t s = stream->FileSize() - stream->Tell(); const size_t filesize = mStream->FileSize() - mStream->Tell();
if (!s) { if (0 == filesize) {
throw DeadlyImportError("StreamReader: File is empty or EOF is already reached"); throw DeadlyImportError("StreamReader: File is empty or EOF is already reached");
} }
current = buffer = new int8_t[s]; mCurrent = mBuffer = new int8_t[filesize];
const size_t read = stream->Read(current,1,s); const size_t read = mStream->Read(mCurrent, 1, filesize);
// (read < s) can only happen if the stream was opened in text mode, in which case FileSize() is not reliable // (read < s) can only happen if the stream was opened in text mode, in which case FileSize() is not reliable
ai_assert(read <= s); ai_assert(read <= filesize);
end = limit = &buffer[read-1] + 1; mEnd = mLimit = &mBuffer[read - 1] + 1;
} }
private: private:
std::shared_ptr<IOStream> stream; std::shared_ptr<IOStream> mStream;
int8_t *buffer, *current, *end, *limit; int8_t *mBuffer;
bool le; int8_t *mCurrent;
int8_t *mEnd;
int8_t *mLimit;
bool mLe;
}; };
// -------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------

View File

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

View File

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

Binary file not shown.

View File

@ -0,0 +1,93 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "UnitTestPCH.h"
#include <assimp/scene.h>
using namespace Assimp;
class utScene : public ::testing::Test {
protected:
aiScene *scene;
void SetUp() override {
scene = new aiScene;
}
void TearDown() override {
delete scene;
scene = nullptr;
}
};
TEST_F(utScene, findNodeTest) {
scene->mRootNode = new aiNode();
scene->mRootNode->mName.Set("test");
aiNode *child = new aiNode;
child->mName.Set("child");
scene->mRootNode->addChildren(1, &child);
aiNode *found = scene->mRootNode->FindNode("child");
EXPECT_EQ(child, found);
}
TEST_F(utScene, sceneHasContentTest) {
EXPECT_FALSE(scene->HasAnimations());
EXPECT_FALSE(scene->HasMaterials());
EXPECT_FALSE(scene->HasMeshes());
EXPECT_FALSE(scene->HasCameras());
EXPECT_FALSE(scene->HasLights());
EXPECT_FALSE(scene->HasTextures());
}
TEST_F(utScene, getShortFilenameTest) {
std::string long_filename1 = "foo_bar/name";
const char *name1 = scene->GetShortFilename(long_filename1.c_str());
EXPECT_NE(nullptr, name1);
std::string long_filename2 = "foo_bar\\name";
const char *name2 = scene->GetShortFilename(long_filename2.c_str());
EXPECT_NE(nullptr, name2);
}
TEST_F(utScene, getEmbeddedTextureTest) {
}

View File

@ -0,0 +1,76 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2019, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "AbstractImportExportBase.h"
#include "SceneDiffer.h"
#include "UnitTestPCH.h"
#include <assimp/postprocess.h>
#include <assimp/Importer.hpp>
#include <assimp/Exporter.hpp>
using namespace Assimp;
class utAssxmlImportExport : public AbstractImportExportBase {
public:
bool importerTest() override {
return true;
}
#ifndef ASSIMP_BUILD_NO_EXPORT
bool exporterTest() override {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure);
EXPECT_NE(scene, nullptr );
::Assimp::Exporter exporter;
return AI_SUCCESS == exporter.Export(scene, "assxml", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_out.assxml");
}
#endif
};
#ifndef ASSIMP_BUILD_NO_EXPORT
TEST_F(utAssxmlImportExport, exportAssxmlTest) {
EXPECT_TRUE(exporterTest());
}
#endif

View File

@ -0,0 +1,66 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "AbstractImportExportBase.h"
#include "UnitTestPCH.h"
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
using namespace Assimp;
class utIrrImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/IRR/box.irr", aiProcess_ValidateDataStructure);
return nullptr != scene;
}
};
TEST_F(utIrrImportExport, importSimpleIrrTest) {
EXPECT_TRUE(importerTest());
}
TEST_F(utIrrImportExport, importSGIrrTest) {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/IRR/dawfInCellar_SameHierarchy.irr", aiProcess_ValidateDataStructure);
EXPECT_NE( nullptr,scene);
}

View File

@ -0,0 +1,64 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "AbstractImportExportBase.h"
#include "UnitTestPCH.h"
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
using namespace Assimp;
class utRAWImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/RAW/Wuson.raw", aiProcess_ValidateDataStructure);
#ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
return nullptr != scene;
#else
return nullptr == scene;
#endif
}
};
TEST_F(utRAWImportExport, importSimpleRAWTest) {
EXPECT_TRUE(importerTest());
}

View File

@ -0,0 +1,60 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "AbstractImportExportBase.h"
#include "UnitTestPCH.h"
#include <assimp/postprocess.h>
#include <assimp/Importer.hpp>
class utTerragenImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() {
/*Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/TER/RealisticTerrain.ter", aiProcess_ValidateDataStructure);
return nullptr != scene;*/
return true;
}
};
TEST_F(utTerragenImportExport, importX3DFromFileTest) {
EXPECT_TRUE(importerTest());
}

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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