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

Merge branch 'enable_vs_warning_all' of https://github.com/assimp/assimp into enable_vs_warning_all

pull/3012/head
kimkulling 2020-03-11 10:15:25 +01:00
parent f8757322be 7e7555a91b
commit 69551e81ed
12 changed files with 375 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
code/LWO/LWOLoader.cpp
View File

@ -155,12 +155,14 @@ void LWOImporter::InternReadFile(const std::string &pFile,
// Allocate storage and copy the contents of the file to a memory buffer // Allocate storage and copy the contents of the file to a memory buffer
std::vector<uint8_t> mBuffer(fileSize); std::vector<uint8_t> mBuffer(fileSize);
file->Read(&mBuffer[0], 1, fileSize); file->Read(&mBuffer[0], 1, fileSize);
this->mScene = pScene; mScene = pScene;
// Determine the type of the file // Determine the type of the file
uint32_t fileType; uint32_t fileType;
const char *sz = IFF::ReadHeader(&mBuffer[0], fileType); const char *sz = IFF::ReadHeader(&mBuffer[0], fileType);
if (sz) throw DeadlyImportError(sz); if (sz) {
throw DeadlyImportError(sz);
}
mFileBuffer = &mBuffer[0] + 12; mFileBuffer = &mBuffer[0] + 12;
fileSize -= 12; fileSize -= 12;
@ -194,18 +196,15 @@ void LWOImporter::InternReadFile(const std::string &pFile,
mIsLWO2 = false; mIsLWO2 = false;
mIsLXOB = false; mIsLXOB = false;
LoadLWOBFile(); LoadLWOBFile();
} } else if (AI_LWO_FOURCC_LWO2 == fileType) {
// New lightwave format // New lightwave format
else if (AI_LWO_FOURCC_LWO2 == fileType) {
mIsLXOB = false; mIsLXOB = false;
ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)"); ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)");
} } else if (AI_LWO_FOURCC_LXOB == fileType) {
// MODO file format // MODO file format
else if (AI_LWO_FOURCC_LXOB == fileType) {
mIsLXOB = true; mIsLXOB = true;
ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)"); ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)");
} }
// we don't know this format
else { else {
char szBuff[5]; char szBuff[5];
szBuff[0] = (char)(fileType >> 24u); szBuff[0] = (char)(fileType >> 24u);
@ -421,7 +420,7 @@ void LWOImporter::InternReadFile(const std::string &pFile,
// Compute normal vectors for the mesh - we can't use our GenSmoothNormal- // Compute normal vectors for the mesh - we can't use our GenSmoothNormal-
// Step here since it wouldn't handle smoothing groups correctly for LWO. // Step here since it wouldn't handle smoothing groups correctly for LWO.
// So we use a separate implementation. // So we use a separate implementation.
ComputeNormals(mesh, smoothingGroups, _mSurfaces[i]); ComputeNormals(mesh, smoothingGroups, _mSurfaces[j]);
} else { } else {
ASSIMP_LOG_DEBUG("LWO2: No need to compute normals, they're already there"); ASSIMP_LOG_DEBUG("LWO2: No need to compute normals, they're already there");
} }

1
code/glTF/glTFImporter.cpp
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,

3
code/glTF2/glTF2Importer.cpp
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,
@ -96,7 +95,7 @@ glTF2Importer::glTF2Importer() :
BaseImporter(), BaseImporter(),
meshOffsets(), meshOffsets(),
embeddedTexIdxs(), embeddedTexIdxs(),
mScene(NULL) { mScene(nullptr) {
// empty // empty
} }

140
include/assimp/anim.h
View File

@ -54,8 +54,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#include <assimp/types.h>
#include <assimp/quaternion.h> #include <assimp/quaternion.h>
#include <assimp/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -63,8 +63,7 @@ extern "C" {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** A time-value pair specifying a certain 3D vector for the given time. */ /** A time-value pair specifying a certain 3D vector for the given time. */
struct aiVectorKey struct aiVectorKey {
{
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
@ -75,16 +74,15 @@ struct aiVectorKey
/// @brief The default constructor. /// @brief The default constructor.
aiVectorKey() AI_NO_EXCEPT aiVectorKey() AI_NO_EXCEPT
: mTime( 0.0 ) : mTime(0.0),
, mValue() { mValue() {
// empty // empty
} }
/// @brief Construction from a given time and key value. /// @brief Construction from a given time and key value.
aiVectorKey(double time, const aiVector3D& value) aiVectorKey(double time, const aiVector3D &value) :
: mTime( time ) mTime(time), mValue(value) {
, mValue( value ) {
// empty // empty
} }
@ -111,8 +109,7 @@ struct aiVectorKey
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** A time-value pair specifying a rotation for the given time. /** A time-value pair specifying a rotation for the given time.
* Rotations are expressed with quaternions. */ * Rotations are expressed with quaternions. */
struct aiQuatKey struct aiQuatKey {
{
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
@ -121,16 +118,14 @@ struct aiQuatKey
#ifdef __cplusplus #ifdef __cplusplus
aiQuatKey() AI_NO_EXCEPT aiQuatKey() AI_NO_EXCEPT
: mTime( 0.0 ) : mTime(0.0),
, mValue() { mValue() {
// empty // empty
} }
/** Construction from a given time and key value */ /** Construction from a given time and key value */
aiQuatKey(double time, const aiQuaternion& value) aiQuatKey(double time, const aiQuaternion &value) :
: mTime (time) mTime(time), mValue(value) {}
, mValue (value)
{}
typedef aiQuaternion elem_type; typedef aiQuaternion elem_type;
@ -154,8 +149,7 @@ struct aiQuatKey
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Binds a anim-mesh to a specific point in time. */ /** Binds a anim-mesh to a specific point in time. */
struct aiMeshKey struct aiMeshKey {
{
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
@ -168,16 +162,13 @@ struct aiMeshKey
#ifdef __cplusplus #ifdef __cplusplus
aiMeshKey() AI_NO_EXCEPT aiMeshKey() AI_NO_EXCEPT
: mTime(0.0) : mTime(0.0),
, mValue(0) mValue(0) {
{
} }
/** Construction from a given time and key value */ /** Construction from a given time and key value */
aiMeshKey(double time, const unsigned int value) aiMeshKey(double time, const unsigned int value) :
: mTime (time) mTime(time), mValue(value) {}
, mValue (value)
{}
typedef unsigned int elem_type; typedef unsigned int elem_type;
@ -202,8 +193,7 @@ struct aiMeshKey
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Binds a morph anim mesh to a specific point in time. */ /** Binds a morph anim mesh to a specific point in time. */
struct aiMeshMorphKey struct aiMeshMorphKey {
{
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
@ -215,16 +205,13 @@ struct aiMeshMorphKey
unsigned int mNumValuesAndWeights; unsigned int mNumValuesAndWeights;
#ifdef __cplusplus #ifdef __cplusplus
aiMeshMorphKey() AI_NO_EXCEPT aiMeshMorphKey() AI_NO_EXCEPT
: mTime(0.0) : mTime(0.0),
, mValues(nullptr) mValues(nullptr),
, mWeights(nullptr) mWeights(nullptr),
, mNumValuesAndWeights(0) mNumValuesAndWeights(0) {
{
} }
~aiMeshMorphKey() ~aiMeshMorphKey() {
{
if (mNumValuesAndWeights && mValues && mWeights) { if (mNumValuesAndWeights && mValues && mWeights) {
delete[] mValues; delete[] mValues;
delete[] mWeights; delete[] mWeights;
@ -237,8 +224,7 @@ struct aiMeshMorphKey
/** Defines how an animation channel behaves outside the defined time /** Defines how an animation channel behaves outside the defined time
* range. This corresponds to aiNodeAnim::mPreState and * range. This corresponds to aiNodeAnim::mPreState and
* aiNodeAnim::mPostState.*/ * aiNodeAnim::mPostState.*/
enum aiAnimBehaviour enum aiAnimBehaviour {
{
/** The value from the default node transformation is taken*/ /** The value from the default node transformation is taken*/
aiAnimBehaviour_DEFAULT = 0x0, aiAnimBehaviour_DEFAULT = 0x0,
@ -329,14 +315,14 @@ struct aiNodeAnim {
#ifdef __cplusplus #ifdef __cplusplus
aiNodeAnim() AI_NO_EXCEPT aiNodeAnim() AI_NO_EXCEPT
: mNumPositionKeys( 0 ) : mNumPositionKeys(0),
, mPositionKeys( nullptr ) mPositionKeys(nullptr),
, mNumRotationKeys( 0 ) mNumRotationKeys(0),
, mRotationKeys( nullptr ) mRotationKeys(nullptr),
, mNumScalingKeys( 0 ) mNumScalingKeys(0),
, mScalingKeys( nullptr ) mScalingKeys(nullptr),
, mPreState( aiAnimBehaviour_DEFAULT ) mPreState(aiAnimBehaviour_DEFAULT),
, mPostState( aiAnimBehaviour_DEFAULT ) { mPostState(aiAnimBehaviour_DEFAULT) {
// empty // empty
} }
@ -354,8 +340,7 @@ struct aiNodeAnim {
* aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to * aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to
* define keyframes linking each mesh attachment to a particular * define keyframes linking each mesh attachment to a particular
* point in time. */ * point in time. */
struct aiMeshAnim struct aiMeshAnim {
{
/** Name of the mesh to be animated. An empty string is not allowed, /** Name of the mesh to be animated. An empty string is not allowed,
* animated meshes need to be named (not necessarily uniquely, * animated meshes need to be named (not necessarily uniquely,
* the name can basically serve as wild-card to select a group * the name can basically serve as wild-card to select a group
@ -371,12 +356,10 @@ struct aiMeshAnim
#ifdef __cplusplus #ifdef __cplusplus
aiMeshAnim() AI_NO_EXCEPT aiMeshAnim() AI_NO_EXCEPT
: mNumKeys() : mNumKeys(),
, mKeys() mKeys() {}
{}
~aiMeshAnim() ~aiMeshAnim() {
{
delete[] mKeys; delete[] mKeys;
} }
@ -385,8 +368,7 @@ struct aiMeshAnim
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Describes a morphing animation of a given mesh. */ /** Describes a morphing animation of a given mesh. */
struct aiMeshMorphAnim struct aiMeshMorphAnim {
{
/** Name of the mesh to be animated. An empty string is not allowed, /** Name of the mesh to be animated. An empty string is not allowed,
* animated meshes need to be named (not necessarily uniquely, * animated meshes need to be named (not necessarily uniquely,
* the name can basically serve as wildcard to select a group * the name can basically serve as wildcard to select a group
@ -402,12 +384,10 @@ struct aiMeshMorphAnim
#ifdef __cplusplus #ifdef __cplusplus
aiMeshMorphAnim() AI_NO_EXCEPT aiMeshMorphAnim() AI_NO_EXCEPT
: mNumKeys() : mNumKeys(),
, mKeys() mKeys() {}
{}
~aiMeshMorphAnim() ~aiMeshMorphAnim() {
{
delete[] mKeys; delete[] mKeys;
} }
@ -437,7 +417,6 @@ struct aiAnimation {
* The array is mNumChannels in size. */ * The array is mNumChannels in size. */
C_STRUCT aiNodeAnim **mChannels; C_STRUCT aiNodeAnim **mChannels;
/** The number of mesh animation channels. Each channel affects /** The number of mesh animation channels. Each channel affects
* a single mesh and defines vertex-based animation. */ * a single mesh and defines vertex-based animation. */
unsigned int mNumMeshChannels; unsigned int mNumMeshChannels;
@ -456,14 +435,14 @@ struct aiAnimation {
#ifdef __cplusplus #ifdef __cplusplus
aiAnimation() AI_NO_EXCEPT aiAnimation() AI_NO_EXCEPT
: mDuration(-1.) : mDuration(-1.),
, mTicksPerSecond(0.) mTicksPerSecond(0.),
, mNumChannels(0) mNumChannels(0),
, mChannels(nullptr) mChannels(nullptr),
, mNumMeshChannels(0) mNumMeshChannels(0),
, mMeshChannels(nullptr) mMeshChannels(nullptr),
, mNumMorphMeshChannels(0) mNumMorphMeshChannels(0),
, mMorphMeshChannels(nullptr) { mMorphMeshChannels(nullptr) {
// empty // empty
} }
@ -495,7 +474,6 @@ struct aiAnimation {
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
/// @brief Some C++ utilities for inter- and extrapolation /// @brief Some C++ utilities for inter- and extrapolation
@ -509,16 +487,15 @@ namespace Assimp {
* types of the arguments. * types of the arguments.
*/ */
template <typename T> template <typename T>
struct Interpolator struct Interpolator {
{
// ------------------------------------------------------------------ // ------------------------------------------------------------------
/** @brief Get the result of the interpolation between a,b. /** @brief Get the result of the interpolation between a,b.
* *
* The interpolation algorithm depends on the type of the operands. * The interpolation algorithm depends on the type of the operands.
* aiQuaternion's and aiQuatKey's SLERP, the rest does a simple * aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
* linear interpolation. */ * linear interpolation. */
void operator () (T& out,const T& a, const T& b, ai_real d) const { void operator()(T &anim_out, const T &a, const T &b, ai_real d) const {
out = a + (b-a)*d; anim_out = a + (b - a) * d;
} }
}; // ! Interpolator <T> }; // ! Interpolator <T>
@ -527,8 +504,7 @@ struct Interpolator
template <> template <>
struct Interpolator<aiQuaternion> { struct Interpolator<aiQuaternion> {
void operator()(aiQuaternion &out, const aiQuaternion &a, void operator()(aiQuaternion &out, const aiQuaternion &a,
const aiQuaternion& b, ai_real d) const const aiQuaternion &b, ai_real d) const {
{
aiQuaternion::Interpolate(out, a, b, d); aiQuaternion::Interpolate(out, a, b, d);
} }
}; // ! Interpolator <aiQuaternion> }; // ! Interpolator <aiQuaternion>
@ -536,8 +512,7 @@ struct Interpolator <aiQuaternion> {
template <> template <>
struct Interpolator<unsigned int> { struct Interpolator<unsigned int> {
void operator()(unsigned int &out, unsigned int a, void operator()(unsigned int &out, unsigned int a,
unsigned int b, ai_real d) const unsigned int b, ai_real d) const {
{
out = d > 0.5f ? b : a; out = d > 0.5f ? b : a;
} }
}; // ! Interpolator <aiQuaternion> }; // ! Interpolator <aiQuaternion>
@ -545,8 +520,7 @@ struct Interpolator <unsigned int> {
template <> template <>
struct Interpolator<aiVectorKey> { struct Interpolator<aiVectorKey> {
void operator()(aiVector3D &out, const aiVectorKey &a, void operator()(aiVector3D &out, const aiVectorKey &a,
const aiVectorKey& b, ai_real d) const const aiVectorKey &b, ai_real d) const {
{
Interpolator<aiVector3D> ipl; Interpolator<aiVector3D> ipl;
ipl(out, a.mValue, b.mValue, d); ipl(out, a.mValue, b.mValue, d);
} }
@ -555,8 +529,7 @@ struct Interpolator<aiVectorKey> {
template <> template <>
struct Interpolator<aiQuatKey> { struct Interpolator<aiQuatKey> {
void operator()(aiQuaternion &out, const aiQuatKey &a, void operator()(aiQuaternion &out, const aiQuatKey &a,
const aiQuatKey& b, ai_real d) const const aiQuatKey &b, ai_real d) const {
{
Interpolator<aiQuaternion> ipl; Interpolator<aiQuaternion> ipl;
ipl(out, a.mValue, b.mValue, d); ipl(out, a.mValue, b.mValue, d);
} }
@ -565,8 +538,7 @@ struct Interpolator<aiQuatKey> {
template <> template <>
struct Interpolator<aiMeshKey> { struct Interpolator<aiMeshKey> {
void operator()(unsigned int &out, const aiMeshKey &a, void operator()(unsigned int &out, const aiMeshKey &a,
const aiMeshKey& b, ai_real d) const const aiMeshKey &b, ai_real d) const {
{
Interpolator<unsigned int> ipl; Interpolator<unsigned int> ipl;
ipl(out, a.mValue, b.mValue, d); ipl(out, a.mValue, b.mValue, d);
} }
@ -574,7 +546,7 @@ struct Interpolator<aiMeshKey> {
//! @endcond //! @endcond
} // ! end namespace Assimp } // namespace Assimp
#endif // __cplusplus #endif // __cplusplus

1
test/unit/ImportExport/utExporter.cpp
View File

@ -60,6 +60,7 @@ public:
} }
bool Update(float percentage = -1.f) override { bool Update(float percentage = -1.f) override {
mPercentage = percentage;
return true; return true;
} }
float mPercentage; float mPercentage;

1
test/unit/ImportExport/utNFFImportExport.cpp
View File

@ -53,7 +53,6 @@ public:
virtual bool importerTest() { virtual bool importerTest() {
Assimp::Importer importer; Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/NFF/NFF/ManyEarthsNotJustOne.nff", 0); const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/NFF/NFF/ManyEarthsNotJustOne.nff", 0);
return true;
return nullptr != scene; return nullptr != scene;
} }
}; };

1
test/unit/utMDCImportExport.cpp
View File

@ -53,7 +53,6 @@ public:
virtual bool importerTest() { virtual bool importerTest() {
Assimp::Importer importer; Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/MDC/spider.mdc", 0); const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/MDC/spider.mdc", 0);
return true;
return nullptr != scene; return nullptr != scene;
} }
}; };

39
test/unit/utObjImportExport.cpp
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,
@ -121,11 +119,11 @@ static const char *ObjModel_Issue1111 =
class utObjImportExport : public AbstractImportExportBase { class utObjImportExport : public AbstractImportExportBase {
protected: protected:
virtual void SetUp() { void SetUp() override {
m_im = new Assimp::Importer; m_im = new Assimp::Importer;
} }
virtual void TearDown() { void TearDown() override {
delete m_im; delete m_im;
m_im = nullptr; m_im = nullptr;
} }
@ -289,7 +287,7 @@ TEST_F(utObjImportExport, issue1923_vertex_color_Test) {
} }
TEST_F(utObjImportExport, issue1453_segfault) { TEST_F(utObjImportExport, issue1453_segfault) {
static const char *CurObjModel = static const char *curObjModel =
"v 0.0 0.0 0.0\n" "v 0.0 0.0 0.0\n"
"v 0.0 0.0 1.0\n" "v 0.0 0.0 1.0\n"
"v 0.0 1.0 0.0\n" "v 0.0 1.0 0.0\n"
@ -300,12 +298,12 @@ TEST_F(utObjImportExport, issue1453_segfault) {
"v 1.0 1.0 1.0\nB"; "v 1.0 1.0 1.0\nB";
Assimp::Importer myimporter; Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), aiProcess_ValidateDataStructure); const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_EQ(nullptr, scene); EXPECT_EQ(nullptr, scene);
} }
TEST_F(utObjImportExport, relative_indices_Test) { TEST_F(utObjImportExport, relative_indices_Test) {
static const char *CurObjModel = static const char *curObjModel =
"v -0.500000 0.000000 0.400000\n" "v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n" "v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n" "v -0.500000 1.000000 -0.800000\n"
@ -313,7 +311,7 @@ TEST_F(utObjImportExport, relative_indices_Test) {
"f -4 -3 -2 -1\nB"; "f -4 -3 -2 -1\nB";
Assimp::Importer myimporter; Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), aiProcess_ValidateDataStructure); const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene); EXPECT_NE(nullptr, scene);
EXPECT_EQ(scene->mNumMeshes, 1U); EXPECT_EQ(scene->mNumMeshes, 1U);
@ -328,14 +326,14 @@ TEST_F(utObjImportExport, relative_indices_Test) {
} }
TEST_F(utObjImportExport, homogeneous_coordinates_Test) { TEST_F(utObjImportExport, homogeneous_coordinates_Test) {
static const char *CurObjModel = static const char *curObjModel =
"v -0.500000 0.000000 0.400000 0.50000\n" "v -0.500000 0.000000 0.400000 0.50000\n"
"v -0.500000 0.000000 -0.800000 1.00000\n" "v -0.500000 0.000000 -0.800000 1.00000\n"
"v 0.500000 1.000000 -0.800000 0.5000\n" "v 0.500000 1.000000 -0.800000 0.5000\n"
"f 1 2 3\nB"; "f 1 2 3\nB";
Assimp::Importer myimporter; Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), aiProcess_ValidateDataStructure); const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene); EXPECT_NE(nullptr, scene);
EXPECT_EQ(scene->mNumMeshes, 1U); EXPECT_EQ(scene->mNumMeshes, 1U);
@ -351,31 +349,31 @@ TEST_F(utObjImportExport, homogeneous_coordinates_Test) {
} }
TEST_F(utObjImportExport, homogeneous_coordinates_divide_by_zero_Test) { TEST_F(utObjImportExport, homogeneous_coordinates_divide_by_zero_Test) {
static const char *CurObjModel = static const char *curObjModel =
"v -0.500000 0.000000 0.400000 0.\n" "v -0.500000 0.000000 0.400000 0.\n"
"v -0.500000 0.000000 -0.800000 1.00000\n" "v -0.500000 0.000000 -0.800000 1.00000\n"
"v 0.500000 1.000000 -0.800000 0.5000\n" "v 0.500000 1.000000 -0.800000 0.5000\n"
"f 1 2 3\nB"; "f 1 2 3\nB";
Assimp::Importer myimporter; Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), aiProcess_ValidateDataStructure); const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_EQ(nullptr, scene); EXPECT_EQ(nullptr, scene);
} }
TEST_F(utObjImportExport, 0based_array_Test) { TEST_F(utObjImportExport, 0based_array_Test) {
static const char *CurObjModel = static const char *curObjModel =
"v -0.500000 0.000000 0.400000\n" "v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n" "v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n" "v -0.500000 1.000000 -0.800000\n"
"f 0 1 2\nB"; "f 0 1 2\nB";
Assimp::Importer myImporter; Assimp::Importer myImporter;
const aiScene *scene = myImporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), 0); const aiScene *scene = myImporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), 0);
EXPECT_EQ(nullptr, scene); EXPECT_EQ(nullptr, scene);
} }
TEST_F(utObjImportExport, invalid_normals_uvs) { TEST_F(utObjImportExport, invalid_normals_uvs) {
static const char *CurObjModel = static const char *curObjModel =
"v -0.500000 0.000000 0.400000\n" "v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n" "v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n" "v -0.500000 1.000000 -0.800000\n"
@ -384,12 +382,12 @@ TEST_F(utObjImportExport, invalid_normals_uvs) {
"f 1/1/1 1/1/1 2/2/2\nB"; "f 1/1/1 1/1/1 2/2/2\nB";
Assimp::Importer myImporter; Assimp::Importer myImporter;
const aiScene *scene = myImporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), 0); const aiScene *scene = myImporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), 0);
EXPECT_NE(nullptr, scene); EXPECT_NE(nullptr, scene);
} }
TEST_F(utObjImportExport, no_vt_just_vns) { TEST_F(utObjImportExport, no_vt_just_vns) {
static const char *CurObjModel = static const char *curObjModel =
"v 0 0 0\n" "v 0 0 0\n"
"v 0 0 0\n" "v 0 0 0\n"
"v 0 0 0\n" "v 0 0 0\n"
@ -417,7 +415,7 @@ TEST_F(utObjImportExport, no_vt_just_vns) {
"f 10/10 11/11 12/12\n"; "f 10/10 11/11 12/12\n";
Assimp::Importer myImporter; Assimp::Importer myImporter;
const aiScene *scene = myImporter.ReadFileFromMemory(CurObjModel, strlen(CurObjModel), 0); const aiScene *scene = myImporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), 0);
EXPECT_NE(nullptr, scene); EXPECT_NE(nullptr, scene);
} }
@ -447,7 +445,7 @@ TEST_F(utObjImportExport, import_without_linend) {
} }
TEST_F(utObjImportExport, import_with_line_continuations) { TEST_F(utObjImportExport, import_with_line_continuations) {
static const char *ObjModel = static const char *curObjModel =
"v -0.5 -0.5 0.5\n" "v -0.5 -0.5 0.5\n"
"v -0.5 \\\n" "v -0.5 \\\n"
" -0.5 -0.5\n" " -0.5 -0.5\n"
@ -457,7 +455,7 @@ TEST_F(utObjImportExport, import_with_line_continuations) {
"f 1 2 3\n"; "f 1 2 3\n";
Assimp::Importer myImporter; Assimp::Importer myImporter;
const aiScene *scene = myImporter.ReadFileFromMemory(ObjModel, strlen(ObjModel), 0); const aiScene *scene = myImporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), 0);
EXPECT_NE(nullptr, scene); EXPECT_NE(nullptr, scene);
EXPECT_EQ(scene->mNumMeshes, 1U); EXPECT_EQ(scene->mNumMeshes, 1U);
@ -479,3 +477,4 @@ TEST_F(utObjImportExport, import_with_line_continuations) {
EXPECT_NEAR(vertices[2].y, 0.5f, threshold); EXPECT_NEAR(vertices[2].y, 0.5f, threshold);
EXPECT_NEAR(vertices[2].z, -0.5f, threshold); EXPECT_NEAR(vertices[2].z, -0.5f, threshold);
} }

7
test/unit/utTriangulate.cpp
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,
@ -112,11 +110,11 @@ TEST_F(TriangulateProcessTest, testTriangulation) {
std::vector<bool> ait(q,false); std::vector<bool> ait(q,false);
for (unsigned int i = 0, tt = q-2; i < tt; ++i,++m) { for (unsigned int i = 0, tt = q-2; i < tt; ++i,++m) {
const aiFace& curFace = pcMesh->mFaces[m]; aiFace& curFace = pcMesh->mFaces[m];
EXPECT_EQ(3U, curFace.mNumIndices); EXPECT_EQ(3U, curFace.mNumIndices);
for (unsigned int qqq = 0; qqq < curFace.mNumIndices; ++qqq) { for (unsigned int qqq = 0; qqq < curFace.mNumIndices; ++qqq) {
ait[face.mIndices[qqq]-idx] = true; ait[curFace.mIndices[qqq] - idx] = true;
} }
} }
for (std::vector<bool>::const_iterator it = ait.begin(); it != ait.end(); ++it) { for (std::vector<bool>::const_iterator it = ait.begin(); it != ait.end(); ++it) {
@ -139,3 +137,4 @@ TEST_F(TriangulateProcessTest, testTriangulation) {
// we should have no valid normal vectors now necause we aren't a pure polygon mesh // we should have no valid normal vectors now necause we aren't a pure polygon mesh
EXPECT_TRUE(pcMesh->mNormals == NULL); EXPECT_TRUE(pcMesh->mNormals == NULL);
} }

25
tools/assimp_cmd/Export.cpp
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,
@ -46,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "Main.h" #include "Main.h"
#include <assimp/ParsingUtils.h>
#ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_EXPORT
@ -53,13 +52,10 @@ const char* AICMD_MSG_EXPORT_HELP_E =
"assimp export <model> [<out>] [-f<h>] [common parameters]\n" "assimp export <model> [<out>] [-f<h>] [common parameters]\n"
"\t -f<h> Specify the file format. If omitted, the output format is \n" "\t -f<h> Specify the file format. If omitted, the output format is \n"
"\t\tderived from the file extension of the given output file \n" "\t\tderived from the file extension of the given output file \n"
"\t[See the assimp_cmd docs for a full list of all common parameters] \n" "\t[See the assimp_cmd docs for a full list of all common parameters] \n";
;
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
size_t GetMatchingFormat(const std::string& outf,bool byext=false) size_t GetMatchingFormat(const std::string &outf, bool byext = false) {
{
for (size_t i = 0, end = globalExporter->GetExportFormatCount(); i < end; ++i) { for (size_t i = 0, end = globalExporter->GetExportFormatCount(); i < end; ++i) {
const aiExportFormatDesc *const e = globalExporter->GetExportFormatDescription(i); const aiExportFormatDesc *const e = globalExporter->GetExportFormatDescription(i);
if (outf == (byext ? e->fileExtension : e->id)) { if (outf == (byext ? e->fileExtension : e->id)) {
@ -69,10 +65,8 @@ size_t GetMatchingFormat(const std::string& outf,bool byext=false)
return SIZE_MAX; return SIZE_MAX;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
int Assimp_Export(const char* const* params, unsigned int num) int Assimp_Export(const char *const *params, unsigned int num) {
{
const char *const invalid = "assimp export: Invalid number of arguments. See \'assimp export --help\'\n"; const char *const invalid = "assimp export: Invalid number of arguments. See \'assimp export --help\'\n";
if (num < 1) { if (num < 1) {
printf(invalid); printf(invalid);
@ -108,13 +102,12 @@ int Assimp_Export(const char* const* params, unsigned int num)
if (!strncmp(params[i], "-f", 2)) { if (!strncmp(params[i], "-f", 2)) {
if (strncmp(params[i], "-fi", 3)) if (strncmp(params[i], "-fi", 3))
outf = std::string(params[i] + 2); outf = std::string(params[i] + 2);
} } else if (!strncmp(params[i], "--format=", 9)) {
else if ( !strncmp( params[i], "--format=",9)) {
outf = std::string(params[i] + 9); outf = std::string(params[i] + 9);
} }
} }
std::transform(outf.begin(),outf.end(),outf.begin(),::tolower); std::transform(outf.begin(), outf.end(), outf.begin(), Assimp::ToLower<char>);
// convert the output format to a format id // convert the output format to a format id
size_t outfi = GetMatchingFormat(outf); size_t outfi = GetMatchingFormat(outf);
@ -134,8 +127,7 @@ int Assimp_Export(const char* const* params, unsigned int num)
printf("assimp export: no output format specified and I failed to guess it\n"); printf("assimp export: no output format specified and I failed to guess it\n");
return -23; return -23;
} }
} } else {
else {
outext = outf; outext = outf;
} }
} }
@ -147,7 +139,7 @@ int Assimp_Export(const char* const* params, unsigned int num)
pos = in.length(); pos = in.length();
} }
out = in.substr(0,s); out = in.substr(0, pos);
} }
const aiExportFormatDesc *const e = globalExporter->GetExportFormatDescription(outfi); const aiExportFormatDesc *const e = globalExporter->GetExportFormatDescription(outfi);
@ -171,4 +163,3 @@ int Assimp_Export(const char* const* params, unsigned int num)
} }
#endif // no export #endif // no export

76
tools/assimp_cmd/ImageExtractor.cpp
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,
@ -46,10 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "Main.h" #include "Main.h"
#include <assimp/fast_atof.h> #include <assimp/ParsingUtils.h>
#include <assimp/StringComparison.h> #include <assimp/StringComparison.h>
#include <assimp/fast_atof.h>
const char* AICMD_MSG_DUMP_HELP_E = static const char *AICMD_MSG_DUMP_HELP_E =
"assimp extract <model> [<out>] [-t<n>] [-f<fmt>] [-ba] [-s] [common parameters]\n" "assimp extract <model> [<out>] [-t<n>] [-f<fmt>] [-ba] [-s] [common parameters]\n"
"\t -ba Writes BMP's with alpha channel\n" "\t -ba Writes BMP's with alpha channel\n"
"\t -t<n> Zero-based index of the texture to be extracted \n" "\t -t<n> Zero-based index of the texture to be extracted \n"
@ -57,16 +56,14 @@ const char* AICMD_MSG_DUMP_HELP_E =
"\t[See the assimp_cmd docs for a full list of all common parameters] \n" "\t[See the assimp_cmd docs for a full list of all common parameters] \n"
"\t -cfast Fast post processing preset, runs just a few important steps \n" "\t -cfast Fast post processing preset, runs just a few important steps \n"
"\t -cdefault Default post processing: runs all recommended steps\n" "\t -cdefault Default post processing: runs all recommended steps\n"
"\t -cfull Fires almost all post processing steps \n" "\t -cfull Fires almost all post processing steps \n";
;
#define AI_EXTRACT_WRITE_BMP_ALPHA 0x1 #define AI_EXTRACT_WRITE_BMP_ALPHA 0x1
#include <assimp/Compiler/pushpack1.h> #include <assimp/Compiler/pushpack1.h>
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Data structure for the first header of a BMP // Data structure for the first header of a BMP
struct BITMAPFILEHEADER struct BITMAPFILEHEADER {
{
uint16_t bfType; uint16_t bfType;
uint32_t bfSize; uint32_t bfSize;
uint16_t bfReserved1; uint16_t bfReserved1;
@ -76,8 +73,7 @@ struct BITMAPFILEHEADER
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Data structure for the second header of a BMP // Data structure for the second header of a BMP
struct BITMAPINFOHEADER struct BITMAPINFOHEADER {
{
int32_t biSize; int32_t biSize;
int32_t biWidth; int32_t biWidth;
int32_t biHeight; int32_t biHeight;
@ -95,14 +91,13 @@ struct BITMAPINFOHEADER
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Data structure for the header of a TGA // Data structure for the header of a TGA
struct TGA_HEADER struct TGA_HEADER {
{
uint8_t identsize; // size of ID field that follows 18 byte header (0 usually) uint8_t identsize; // size of ID field that follows 18 byte header (0 usually)
uint8_t colourmaptype; // type of colour map 0=none, 1=has palette uint8_t colourmaptype; // type of colour map 0=none, 1=has palette
uint8_t imagetype; // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed uint8_t imagetype; // type of image 0=none,1=indexed,2=rgb,3=gray,+8=rle packed
uint16_t colourmapstart; // first colour map entry in palette uint16_t colourmapstart; // first colour map entry in palette
uint16_t colourmaplength; // number of colours in palette uint16_t colourmaplength; // number of colors in palette
uint8_t colourmapbits; // number of bits per palette entry 15,16,24,32 uint8_t colourmapbits; // number of bits per palette entry 15,16,24,32
uint16_t xstart; // image x origin uint16_t xstart; // image x origin
@ -115,13 +110,11 @@ struct TGA_HEADER
// pixel data follows header // pixel data follows header
} PACK_STRUCT; } PACK_STRUCT;
#include <assimp/Compiler/poppack1.h> #include <assimp/Compiler/poppack1.h>
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Save a texture as bitmap // Save a texture as bitmap
int SaveAsBMP (FILE* file, const aiTexel* data, unsigned int width, unsigned int height, bool SaveAlpha = false) int SaveAsBMP(FILE *file, const aiTexel *data, unsigned int width, unsigned int height, bool SaveAlpha = false) {
{
if (!file || !data) { if (!file || !data) {
return 1; return 1;
} }
@ -179,8 +172,7 @@ int SaveAsBMP (FILE* file, const aiTexel* data, unsigned int width, unsigned int
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Save a texture as tga // Save a texture as tga
int SaveAsTGA (FILE* file, const aiTexel* data, unsigned int width, unsigned int height) int SaveAsTGA(FILE *file, const aiTexel *data, unsigned int width, unsigned int height) {
{
if (!file || !data) { if (!file || !data) {
return 1; return 1;
} }
@ -207,17 +199,14 @@ int SaveAsTGA (FILE* file, const aiTexel* data, unsigned int width, unsigned int
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Do the texture import for a given aiTexture // Do the texture import for a given aiTexture
int DoExport(const aiTexture *tx, FILE *p, const std::string &extension, int DoExport(const aiTexture *tx, FILE *p, const std::string &extension,
unsigned int flags) unsigned int flags) {
{
// export the image to the appropriate decoder // export the image to the appropriate decoder
if (extension == "bmp") { if (extension == "bmp") {
SaveAsBMP(p, tx->pcData, tx->mWidth, tx->mHeight, SaveAsBMP(p, tx->pcData, tx->mWidth, tx->mHeight,
(0 != (flags & AI_EXTRACT_WRITE_BMP_ALPHA))); (0 != (flags & AI_EXTRACT_WRITE_BMP_ALPHA)));
} } else if (extension == "tga") {
else if (extension == "tga") {
SaveAsTGA(p, tx->pcData, tx->mWidth, tx->mHeight); SaveAsTGA(p, tx->pcData, tx->mWidth, tx->mHeight);
} } else {
else {
printf("assimp extract: No available texture encoder found for %s\n", extension.c_str()); printf("assimp extract: No available texture encoder found for %s\n", extension.c_str());
return AssimpCmdExtractError::NoAvailableTextureEncoderFound; return AssimpCmdExtractError::NoAvailableTextureEncoderFound;
} }
@ -226,8 +215,7 @@ int DoExport(const aiTexture* tx, FILE* p, const std::string& extension,
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Implementation of the assimp extract utility // Implementation of the assimp extract utility
int Assimp_Extract (const char* const* params, unsigned int num) int Assimp_Extract(const char *const *params, unsigned int num) {
{
const char *const invalid = "assimp extract: Invalid number of arguments. See \'assimp extract --help\'\n"; const char *const invalid = "assimp extract: Invalid number of arguments. See \'assimp extract --help\'\n";
// assimp extract in out [options] // assimp extract in out [options]
if (num < 1) { if (num < 1) {
@ -241,8 +229,6 @@ int Assimp_Extract (const char* const* params, unsigned int num)
return AssimpCmdError::Success; return AssimpCmdError::Success;
} }
std::string in = std::string(params[0]); std::string in = std::string(params[0]);
std::string out = (num > 1 ? std::string(params[1]) : "-"); std::string out = (num > 1 ? std::string(params[1]) : "-");
@ -262,20 +248,15 @@ int Assimp_Extract (const char* const* params, unsigned int num)
if (!strncmp(params[i], "-f", 2)) { if (!strncmp(params[i], "-f", 2)) {
extension = std::string(params[i] + 2); extension = std::string(params[i] + 2);
} } else if (!strncmp(params[i], "--format=", 9)) {
else if ( !strncmp( params[i], "--format=",9)) {
extension = std::string(params[i] + 9); extension = std::string(params[i] + 9);
} } else if (!strcmp(params[i], "--nosuffix") || !strcmp(params[i], "-s")) {
else if ( !strcmp( params[i], "--nosuffix") || !strcmp(params[i],"-s")) {
nosuffix = true; nosuffix = true;
} } else if (!strncmp(params[i], "--texture=", 10)) {
else if ( !strncmp( params[i], "--texture=",10)) {
texIdx = Assimp::strtoul10(params[i] + 10); texIdx = Assimp::strtoul10(params[i] + 10);
} } else if (!strncmp(params[i], "-t", 2)) {
else if ( !strncmp( params[i], "-t",2)) {
texIdx = Assimp::strtoul10(params[i] + 2); texIdx = Assimp::strtoul10(params[i] + 2);
} } else if (!strcmp(params[i], "-ba") || !strcmp(params[i], "--bmp-with-alpha")) {
else if ( !strcmp( params[i], "-ba") || !strcmp( params[i], "--bmp-with-alpha")) {
flags |= AI_EXTRACT_WRITE_BMP_ALPHA; flags |= AI_EXTRACT_WRITE_BMP_ALPHA;
} }
#if 0 #if 0
@ -286,7 +267,7 @@ int Assimp_Extract (const char* const* params, unsigned int num)
#endif #endif
} }
std::transform(extension.begin(),extension.end(),extension.begin(),::tolower); std::transform(extension.begin(), extension.end(), extension.begin(), Assimp::ToLower<char>);
if (out[0] == '-') { if (out[0] == '-') {
// take file name from input file // take file name from input file
@ -320,8 +301,7 @@ int Assimp_Extract (const char* const* params, unsigned int num)
texIdx, scene->mNumTextures); texIdx, scene->mNumTextures);
return AssimpCmdExtractError::TextureIndexIsOutOfRange; return AssimpCmdExtractError::TextureIndexIsOutOfRange;
} }
} } else {
else {
::printf("assimp extract: Exporting %i textures\n", scene->mNumTextures); ::printf("assimp extract: Exporting %i textures\n", scene->mNumTextures);
} }
@ -363,16 +343,18 @@ int Assimp_Extract (const char* const* params, unsigned int num)
int m; int m;
if (!tex->mHeight) { if (!tex->mHeight) {
m = (1 != fwrite(tex->pcData,tex->mWidth,1,p)) m = (1 != fwrite(tex->pcData, tex->mWidth, 1, p)) ?
? static_cast<int>(AssimpCmdError::Success) static_cast<int>(AssimpCmdError::Success) :
: static_cast<int>(AssimpCmdExtractError::FailedToExportCompressedTexture); static_cast<int>(AssimpCmdExtractError::FailedToExportCompressedTexture);
} else {
m = DoExport(tex, p, extension, flags);
} }
else m = DoExport(tex,p,extension,flags);
::fclose(p); ::fclose(p);
printf("assimp extract: Wrote texture %i to %s\n", i, out_cpy.c_str()); printf("assimp extract: Wrote texture %i to %s\n", i, out_cpy.c_str());
if (texIdx != 0xffffffff) if (texIdx != 0xffffffff) {
return m; return m;
} }
return AssimpCmdError::Success; return AssimpCmdError::Success;
} }

22
tools/assimp_cmd/WriteDump.cpp
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,
@ -79,7 +77,7 @@ int Assimp_Dump(const char *const *params, unsigned int num) {
return AssimpCmdError::Success; return AssimpCmdError::Success;
} }
// assimp dump in out [options] // asssimp dump in out [options]
if (num < 1) { if (num < 1) {
printf("%s", fail); printf("%s", fail);
return AssimpCmdError::InvalidNumberOfArguments; return AssimpCmdError::InvalidNumberOfArguments;
@ -104,11 +102,13 @@ int Assimp_Dump(const char *const *params, unsigned int num) {
// process other flags // process other flags
for (unsigned int i = 1; i < num; ++i) { for (unsigned int i = 1; i < num; ++i) {
if (!params[i]) continue; if (!params[i]) {
continue;
}
if (!strcmp(params[i], "-b") || !strcmp(params[i], "--binary")) { if (!strcmp(params[i], "-b") || !strcmp(params[i], "--binary")) {
binary = true; binary = true;
} else if (!strcmp(params[i], "-s") || !strcmp(params[i], "--short")) { } else if (!strcmp(params[i], "-s") || !strcmp(params[i], "--short")) {
cur_shortened = true; shortened = true;
} else if (!strcmp(params[i], "-z") || !strcmp(params[i], "--compressed")) { } else if (!strcmp(params[i], "-z") || !strcmp(params[i], "--compressed")) {
compressed = true; compressed = true;
} }
@ -122,12 +122,12 @@ int Assimp_Dump(const char *const *params, unsigned int num) {
if (cur_out[0] == '-') { if (cur_out[0] == '-') {
// take file name from input file // take file name from input file
std::string::size_type s = in.find_last_of('.'); std::string::size_type pos = in.find_last_of('.');
if (s == std::string::npos) { if (pos == std::string::npos) {
s = in.length(); pos = in.length();
} }
cur_out = in.substr(0, s); cur_out = in.substr(0, pos);
cur_out.append((binary ? ".assbin" : ".assxml")); cur_out.append((binary ? ".assbin" : ".assxml"));
if (cur_shortened && binary) { if (cur_shortened && binary) {
cur_out.append(".regress"); cur_out.append(".regress");
@ -155,10 +155,10 @@ int Assimp_Dump(const char *const *params, unsigned int num) {
printf("%s", ("assimp dump: " + std::string(e.what())).c_str()); printf("%s", ("assimp dump: " + std::string(e.what())).c_str());
return AssimpCmdError::ExceptionWasRaised; return AssimpCmdError::ExceptionWasRaised;
} catch (...) { } catch (...) {
printf("assimp dump: An unknown exception occured.\n"); printf("assimp dump: An unknown exception occurred.\n");
return AssimpCmdError::ExceptionWasRaised; return AssimpCmdError::ExceptionWasRaised;
} }
printf("assimp dump: Wrote output dump %s\n", out.c_str()); printf("assimp dump: Wrote output dump %s\n", cur_out.c_str());
return AssimpCmdError::Success; return AssimpCmdError::Success;
} }