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

fix compiler warnings in tools and test-

pull/3012/head
Kim Kulling 2020-03-11 00:43:44 +01:00
parent 02e5698a38
commit 7e7555a91b
14 changed files with 669 additions and 733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
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
std::vector<uint8_t> mBuffer(fileSize);
file->Read(&mBuffer[0], 1, fileSize);
this->mScene = pScene;
mScene = pScene;
// Determine the type of the file
uint32_t fileType;
const char *sz = IFF::ReadHeader(&mBuffer[0], fileType);
if (sz) throw DeadlyImportError(sz);
if (sz) {
throw DeadlyImportError(sz);
}
mFileBuffer = &mBuffer[0] + 12;
fileSize -= 12;
@ -194,18 +196,15 @@ void LWOImporter::InternReadFile(const std::string &pFile,
mIsLWO2 = false;
mIsLXOB = false;
LoadLWOBFile();
}
// New lightwave format
else if (AI_LWO_FOURCC_LWO2 == fileType) {
} else if (AI_LWO_FOURCC_LWO2 == fileType) {
// New lightwave format
mIsLXOB = false;
ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)");
}
// MODO file format
else if (AI_LWO_FOURCC_LXOB == fileType) {
} else if (AI_LWO_FOURCC_LXOB == fileType) {
// MODO file format
mIsLXOB = true;
ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)");
}
// we don't know this format
else {
char szBuff[5];
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-
// Step here since it wouldn't handle smoothing groups correctly for LWO.
// So we use a separate implementation.
ComputeNormals(mesh, smoothingGroups, _mSurfaces[i]);
ComputeNormals(mesh, smoothingGroups, _mSurfaces[j]);
} else {
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
All rights reserved.
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
All rights reserved.
Redistribution and use of this software in source and binary forms,
@ -96,7 +95,7 @@ glTF2Importer::glTF2Importer() :
BaseImporter(),
meshOffsets(),
embeddedTexIdxs(),
mScene(NULL) {
mScene(nullptr) {
// empty
}

256
include/assimp/anim.h
View File

@ -51,11 +51,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_ANIM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#pragma GCC system_header
#endif
#include <assimp/types.h>
#include <assimp/quaternion.h>
#include <assimp/types.h>
#ifdef __cplusplus
extern "C" {
@ -63,8 +63,7 @@ extern "C" {
// ---------------------------------------------------------------------------
/** A time-value pair specifying a certain 3D vector for the given time. */
struct aiVectorKey
{
struct aiVectorKey {
/** The time of this key */
double mTime;
@ -75,34 +74,33 @@ struct aiVectorKey
/// @brief The default constructor.
aiVectorKey() AI_NO_EXCEPT
: mTime( 0.0 )
, mValue() {
: mTime(0.0),
mValue() {
// empty
}
/// @brief Construction from a given time and key value.
aiVectorKey(double time, const aiVector3D& value)
: mTime( time )
, mValue( value ) {
aiVectorKey(double time, const aiVector3D &value) :
mTime(time), mValue(value) {
// empty
}
typedef aiVector3D elem_type;
// Comparison operators. For use with std::find();
bool operator == (const aiVectorKey& rhs) const {
bool operator==(const aiVectorKey &rhs) const {
return rhs.mValue == this->mValue;
}
bool operator != (const aiVectorKey& rhs ) const {
bool operator!=(const aiVectorKey &rhs) const {
return rhs.mValue != this->mValue;
}
// Relational operators. For use with std::sort();
bool operator < (const aiVectorKey& rhs ) const {
bool operator<(const aiVectorKey &rhs) const {
return mTime < rhs.mTime;
}
bool operator > (const aiVectorKey& rhs ) const {
bool operator>(const aiVectorKey &rhs) const {
return mTime > rhs.mTime;
}
#endif // __cplusplus
@ -111,8 +109,7 @@ struct aiVectorKey
// ---------------------------------------------------------------------------
/** A time-value pair specifying a rotation for the given time.
* Rotations are expressed with quaternions. */
struct aiQuatKey
{
struct aiQuatKey {
/** The time of this key */
double mTime;
@ -121,32 +118,30 @@ struct aiQuatKey
#ifdef __cplusplus
aiQuatKey() AI_NO_EXCEPT
: mTime( 0.0 )
, mValue() {
: mTime(0.0),
mValue() {
// empty
}
/** Construction from a given time and key value */
aiQuatKey(double time, const aiQuaternion& value)
: mTime (time)
, mValue (value)
{}
aiQuatKey(double time, const aiQuaternion &value) :
mTime(time), mValue(value) {}
typedef aiQuaternion elem_type;
// Comparison operators. For use with std::find();
bool operator == (const aiQuatKey& rhs ) const {
bool operator==(const aiQuatKey &rhs) const {
return rhs.mValue == this->mValue;
}
bool operator != (const aiQuatKey& rhs ) const {
bool operator!=(const aiQuatKey &rhs) const {
return rhs.mValue != this->mValue;
}
// Relational operators. For use with std::sort();
bool operator < (const aiQuatKey& rhs ) const {
bool operator<(const aiQuatKey &rhs) const {
return mTime < rhs.mTime;
}
bool operator > (const aiQuatKey& rhs ) const {
bool operator>(const aiQuatKey &rhs) const {
return mTime > rhs.mTime;
}
#endif
@ -154,8 +149,7 @@ struct aiQuatKey
// ---------------------------------------------------------------------------
/** Binds a anim-mesh to a specific point in time. */
struct aiMeshKey
{
struct aiMeshKey {
/** The time of this key */
double mTime;
@ -168,32 +162,29 @@ struct aiMeshKey
#ifdef __cplusplus
aiMeshKey() AI_NO_EXCEPT
: mTime(0.0)
, mValue(0)
{
: mTime(0.0),
mValue(0) {
}
/** Construction from a given time and key value */
aiMeshKey(double time, const unsigned int value)
: mTime (time)
, mValue (value)
{}
aiMeshKey(double time, const unsigned int value) :
mTime(time), mValue(value) {}
typedef unsigned int elem_type;
// Comparison operators. For use with std::find();
bool operator == (const aiMeshKey& o) const {
bool operator==(const aiMeshKey &o) const {
return o.mValue == this->mValue;
}
bool operator != (const aiMeshKey& o) const {
bool operator!=(const aiMeshKey &o) const {
return o.mValue != this->mValue;
}
// Relational operators. For use with std::sort();
bool operator < (const aiMeshKey& o) const {
bool operator<(const aiMeshKey &o) const {
return mTime < o.mTime;
}
bool operator > (const aiMeshKey& o) const {
bool operator>(const aiMeshKey &o) const {
return mTime > o.mTime;
}
@ -202,8 +193,7 @@ struct aiMeshKey
// ---------------------------------------------------------------------------
/** Binds a morph anim mesh to a specific point in time. */
struct aiMeshMorphKey
{
struct aiMeshMorphKey {
/** The time of this key */
double mTime;
@ -214,20 +204,17 @@ struct aiMeshMorphKey
/** The number of values and weights */
unsigned int mNumValuesAndWeights;
#ifdef __cplusplus
aiMeshMorphKey() AI_NO_EXCEPT
: mTime(0.0)
, mValues(nullptr)
, mWeights(nullptr)
, mNumValuesAndWeights(0)
{
aiMeshMorphKey() AI_NO_EXCEPT
: mTime(0.0),
mValues(nullptr),
mWeights(nullptr),
mNumValuesAndWeights(0) {
}
}
~aiMeshMorphKey()
{
~aiMeshMorphKey() {
if (mNumValuesAndWeights && mValues && mWeights) {
delete [] mValues;
delete [] mWeights;
delete[] mValues;
delete[] mWeights;
}
}
#endif
@ -237,25 +224,24 @@ struct aiMeshMorphKey
/** Defines how an animation channel behaves outside the defined time
* range. This corresponds to aiNodeAnim::mPreState and
* aiNodeAnim::mPostState.*/
enum aiAnimBehaviour
{
enum aiAnimBehaviour {
/** The value from the default node transformation is taken*/
aiAnimBehaviour_DEFAULT = 0x0,
aiAnimBehaviour_DEFAULT = 0x0,
/** The nearest key value is used without interpolation */
aiAnimBehaviour_CONSTANT = 0x1,
/** The value of the nearest two keys is linearly
* extrapolated for the current time value.*/
aiAnimBehaviour_LINEAR = 0x2,
aiAnimBehaviour_LINEAR = 0x2,
/** The animation is repeated.
*
* If the animation key go from n to m and the current
* time is t, use the value at (t-n) % (|m-n|).*/
aiAnimBehaviour_REPEAT = 0x3,
aiAnimBehaviour_REPEAT = 0x3,
/** This value is not used, it is just here to force the
/** This value is not used, it is just here to force the
* the compiler to map this enum to a 32 Bit integer */
#ifndef SWIG
_aiAnimBehaviour_Force32Bit = INT_MAX
@ -290,7 +276,7 @@ struct aiNodeAnim {
*
* If there are position keys, there will also be at least one
* scaling and one rotation key.*/
C_STRUCT aiVectorKey* mPositionKeys;
C_STRUCT aiVectorKey *mPositionKeys;
/** The number of rotation keys */
unsigned int mNumRotationKeys;
@ -301,7 +287,7 @@ struct aiNodeAnim {
*
* If there are rotation keys, there will also be at least one
* scaling and one position key. */
C_STRUCT aiQuatKey* mRotationKeys;
C_STRUCT aiQuatKey *mRotationKeys;
/** The number of scaling keys */
unsigned int mNumScalingKeys;
@ -311,7 +297,7 @@ struct aiNodeAnim {
*
* If there are scaling keys, there will also be at least one
* position and one rotation key.*/
C_STRUCT aiVectorKey* mScalingKeys;
C_STRUCT aiVectorKey *mScalingKeys;
/** Defines how the animation behaves before the first
* key is encountered.
@ -329,21 +315,21 @@ struct aiNodeAnim {
#ifdef __cplusplus
aiNodeAnim() AI_NO_EXCEPT
: mNumPositionKeys( 0 )
, mPositionKeys( nullptr )
, mNumRotationKeys( 0 )
, mRotationKeys( nullptr )
, mNumScalingKeys( 0 )
, mScalingKeys( nullptr )
, mPreState( aiAnimBehaviour_DEFAULT )
, mPostState( aiAnimBehaviour_DEFAULT ) {
// empty
: mNumPositionKeys(0),
mPositionKeys(nullptr),
mNumRotationKeys(0),
mRotationKeys(nullptr),
mNumScalingKeys(0),
mScalingKeys(nullptr),
mPreState(aiAnimBehaviour_DEFAULT),
mPostState(aiAnimBehaviour_DEFAULT) {
// empty
}
~aiNodeAnim() {
delete [] mPositionKeys;
delete [] mRotationKeys;
delete [] mScalingKeys;
delete[] mPositionKeys;
delete[] mRotationKeys;
delete[] mScalingKeys;
}
#endif // __cplusplus
};
@ -354,8 +340,7 @@ struct aiNodeAnim {
* aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to
* define keyframes linking each mesh attachment to a particular
* point in time. */
struct aiMeshAnim
{
struct aiMeshAnim {
/** Name of the mesh to be animated. An empty string is not allowed,
* animated meshes need to be named (not necessarily uniquely,
* the name can basically serve as wild-card to select a group
@ -366,17 +351,15 @@ struct aiMeshAnim
unsigned int mNumKeys;
/** Key frames of the animation. May not be NULL. */
C_STRUCT aiMeshKey* mKeys;
C_STRUCT aiMeshKey *mKeys;
#ifdef __cplusplus
aiMeshAnim() AI_NO_EXCEPT
: mNumKeys()
, mKeys()
{}
: mNumKeys(),
mKeys() {}
~aiMeshAnim()
{
~aiMeshAnim() {
delete[] mKeys;
}
@ -385,8 +368,7 @@ struct aiMeshAnim
// ---------------------------------------------------------------------------
/** 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,
* animated meshes need to be named (not necessarily uniquely,
* the name can basically serve as wildcard to select a group
@ -397,17 +379,15 @@ struct aiMeshMorphAnim
unsigned int mNumKeys;
/** Key frames of the animation. May not be NULL. */
C_STRUCT aiMeshMorphKey* mKeys;
C_STRUCT aiMeshMorphKey *mKeys;
#ifdef __cplusplus
aiMeshMorphAnim() AI_NO_EXCEPT
: mNumKeys()
, mKeys()
{}
: mNumKeys(),
mKeys() {}
~aiMeshMorphAnim()
{
~aiMeshMorphAnim() {
delete[] mKeys;
}
@ -435,8 +415,7 @@ struct aiAnimation {
/** The node animation channels. Each channel affects a single node.
* The array is mNumChannels in size. */
C_STRUCT aiNodeAnim** mChannels;
C_STRUCT aiNodeAnim **mChannels;
/** The number of mesh animation channels. Each channel affects
* a single mesh and defines vertex-based animation. */
@ -444,7 +423,7 @@ struct aiAnimation {
/** The mesh animation channels. Each channel affects a single mesh.
* The array is mNumMeshChannels in size. */
C_STRUCT aiMeshAnim** mMeshChannels;
C_STRUCT aiMeshAnim **mMeshChannels;
/** The number of mesh animation channels. Each channel affects
* a single mesh and defines morphing animation. */
@ -456,46 +435,45 @@ struct aiAnimation {
#ifdef __cplusplus
aiAnimation() AI_NO_EXCEPT
: mDuration(-1.)
, mTicksPerSecond(0.)
, mNumChannels(0)
, mChannels(nullptr)
, mNumMeshChannels(0)
, mMeshChannels(nullptr)
, mNumMorphMeshChannels(0)
, mMorphMeshChannels(nullptr) {
: mDuration(-1.),
mTicksPerSecond(0.),
mNumChannels(0),
mChannels(nullptr),
mNumMeshChannels(0),
mMeshChannels(nullptr),
mNumMorphMeshChannels(0),
mMorphMeshChannels(nullptr) {
// empty
}
~aiAnimation() {
// DO NOT REMOVE THIS ADDITIONAL CHECK
if ( mNumChannels && mChannels ) {
for( unsigned int a = 0; a < mNumChannels; a++) {
delete mChannels[ a ];
if (mNumChannels && mChannels) {
for (unsigned int a = 0; a < mNumChannels; a++) {
delete mChannels[a];
}
delete [] mChannels;
delete[] mChannels;
}
if (mNumMeshChannels && mMeshChannels) {
for( unsigned int a = 0; a < mNumMeshChannels; a++) {
if (mNumMeshChannels && mMeshChannels) {
for (unsigned int a = 0; a < mNumMeshChannels; a++) {
delete mMeshChannels[a];
}
delete [] mMeshChannels;
delete[] mMeshChannels;
}
if (mNumMorphMeshChannels && mMorphMeshChannels) {
for( unsigned int a = 0; a < mNumMorphMeshChannels; a++) {
delete mMorphMeshChannels[a];
}
for (unsigned int a = 0; a < mNumMorphMeshChannels; a++) {
delete mMorphMeshChannels[a];
}
delete [] mMorphMeshChannels;
delete[] mMorphMeshChannels;
}
}
#endif // __cplusplus
};
#ifdef __cplusplus
}
/// @brief Some C++ utilities for inter- and extrapolation
@ -509,72 +487,66 @@ namespace Assimp {
* types of the arguments.
*/
template <typename T>
struct Interpolator
{
struct Interpolator {
// ------------------------------------------------------------------
/** @brief Get the result of the interpolation between a,b.
*
* The interpolation algorithm depends on the type of the operands.
* aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
* linear interpolation. */
void operator () (T& out,const T& a, const T& b, ai_real d) const {
out = a + (b-a)*d;
void operator()(T &anim_out, const T &a, const T &b, ai_real d) const {
anim_out = a + (b - a) * d;
}
}; // ! Interpolator <T>
//! @cond Never
template <>
struct Interpolator <aiQuaternion> {
void operator () (aiQuaternion& out,const aiQuaternion& a,
const aiQuaternion& b, ai_real d) const
{
aiQuaternion::Interpolate(out,a,b,d);
struct Interpolator<aiQuaternion> {
void operator()(aiQuaternion &out, const aiQuaternion &a,
const aiQuaternion &b, ai_real d) const {
aiQuaternion::Interpolate(out, a, b, d);
}
}; // ! Interpolator <aiQuaternion>
template <>
struct Interpolator <unsigned int> {
void operator () (unsigned int& out,unsigned int a,
unsigned int b, ai_real d) const
{
out = d>0.5f ? b : a;
struct Interpolator<unsigned int> {
void operator()(unsigned int &out, unsigned int a,
unsigned int b, ai_real d) const {
out = d > 0.5f ? b : a;
}
}; // ! Interpolator <aiQuaternion>
template <>
struct Interpolator<aiVectorKey> {
void operator () (aiVector3D& out,const aiVectorKey& a,
const aiVectorKey& b, ai_real d) const
{
struct Interpolator<aiVectorKey> {
void operator()(aiVector3D &out, const aiVectorKey &a,
const aiVectorKey &b, ai_real d) const {
Interpolator<aiVector3D> ipl;
ipl(out,a.mValue,b.mValue,d);
ipl(out, a.mValue, b.mValue, d);
}
}; // ! Interpolator <aiVectorKey>
template <>
struct Interpolator<aiQuatKey> {
void operator () (aiQuaternion& out, const aiQuatKey& a,
const aiQuatKey& b, ai_real d) const
{
struct Interpolator<aiQuatKey> {
void operator()(aiQuaternion &out, const aiQuatKey &a,
const aiQuatKey &b, ai_real d) const {
Interpolator<aiQuaternion> ipl;
ipl(out,a.mValue,b.mValue,d);
ipl(out, a.mValue, b.mValue, d);
}
}; // ! Interpolator <aiQuatKey>
template <>
struct Interpolator<aiMeshKey> {
void operator () (unsigned int& out, const aiMeshKey& a,
const aiMeshKey& b, ai_real d) const
{
struct Interpolator<aiMeshKey> {
void operator()(unsigned int &out, const aiMeshKey &a,
const aiMeshKey &b, ai_real d) const {
Interpolator<unsigned int> ipl;
ipl(out,a.mValue,b.mValue,d);
ipl(out, a.mValue, b.mValue, d);
}
}; // ! Interpolator <aiQuatKey>
//! @endcond
} // ! end namespace Assimp
} // namespace Assimp
#endif // __cplusplus

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

@ -49,7 +49,9 @@ using namespace Assimp;
class TestProgressHandler : public ProgressHandler {
public:
TestProgressHandler() : ProgressHandler() {
TestProgressHandler() :
ProgressHandler(),
mPercentage(0.f) {
// empty
}
@ -58,8 +60,10 @@ public:
}
bool Update(float percentage = -1.f) override {
mPercentage = percentage;
return true;
}
float mPercentage;
};
class ExporterTest : public ::testing::Test {
@ -77,12 +81,11 @@ TEST_F(ExporterTest, ExporterIdTest) {
Exporter exporter;
size_t exportFormatCount = exporter.GetExportFormatCount();
EXPECT_NE(0u, exportFormatCount) << "No registered exporters";
typedef std::map<std::string, const aiExportFormatDesc*> ExportIdMap;
typedef std::map<std::string, const aiExportFormatDesc *> ExportIdMap;
ExportIdMap exporterMap;
for (size_t i = 0; i < exportFormatCount; ++i)
{
for (size_t i = 0; i < exportFormatCount; ++i) {
// Check that the exporter description exists and makes sense
const aiExportFormatDesc* desc = exporter.GetExportFormatDescription(i);
const aiExportFormatDesc *desc = exporter.GetExportFormatDescription(i);
ASSERT_NE(nullptr, desc) << "Missing aiExportFormatDesc at index " << i;
EXPECT_NE(nullptr, desc->id) << "Null exporter ID at index " << i;
EXPECT_STRNE("", desc->id) << "Empty exporter ID at index " << i;
@ -97,6 +100,6 @@ TEST_F(ExporterTest, ExporterIdTest) {
EXPECT_TRUE(result.second) << "Duplicate exported id: '" << key << "' " << desc->description << " *." << desc->fileExtension << " at index " << i;
}
const aiExportFormatDesc* desc = exporter.GetExportFormatDescription(exportFormatCount);
const aiExportFormatDesc *desc = exporter.GetExportFormatDescription(exportFormatCount);
EXPECT_EQ(nullptr, desc) << "More exporters than claimed";
}

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

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

3
test/unit/SceneDiffer.cpp
View File

@ -88,8 +88,6 @@ bool SceneDiffer::isEqual( const aiScene *expected, const aiScene *toCompare ) {
}
}
// ToDo!
return true;
// materials
if ( expected->mNumMaterials != toCompare->mNumMaterials ) {
std::stringstream stream;
@ -112,6 +110,7 @@ bool SceneDiffer::isEqual( const aiScene *expected, const aiScene *toCompare ) {
std::stringstream stream;
stream << "Materials are not equal, index : " << i << "\n";
addDiff( stream.str() );
return false;
}
}

1
test/unit/utMDCImportExport.cpp
View File

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

453
test/unit/utObjImportExport.cpp
View File

@ -41,83 +41,83 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "UnitTestPCH.h"
#include "SceneDiffer.h"
#include "AbstractImportExportBase.h"
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
#include <assimp/Exporter.hpp>
#include "SceneDiffer.h"
#include "UnitTestPCH.h"
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <assimp/Exporter.hpp>
#include <assimp/Importer.hpp>
using namespace Assimp;
static const float VertComponents[ 24 * 3 ] = {
-0.500000, 0.500000, 0.500000,
-0.500000, 0.500000, -0.500000,
static const float VertComponents[24 * 3] = {
-0.500000, 0.500000, 0.500000,
-0.500000, 0.500000, -0.500000,
-0.500000, -0.500000, -0.500000,
-0.500000, -0.500000, 0.500000,
-0.500000, -0.500000, 0.500000,
-0.500000, -0.500000, -0.500000,
0.500000, -0.500000, -0.500000,
0.500000, -0.500000, 0.500000,
-0.500000, -0.500000, 0.500000,
-0.500000, 0.500000, -0.500000,
0.500000, 0.500000, -0.500000,
0.500000, -0.500000, -0.500000,
0.500000, -0.500000, -0.500000,
0.500000, -0.500000, 0.500000,
-0.500000, -0.500000, 0.500000,
-0.500000, 0.500000, -0.500000,
0.500000, 0.500000, -0.500000,
0.500000, -0.500000, -0.500000,
-0.500000, -0.500000, -0.500000,
0.500000, 0.500000, 0.500000,
0.500000, 0.500000, -0.500000,
-0.500000, 0.500000, -0.500000,
-0.500000, 0.500000, 0.500000,
0.500000, -0.500000, 0.500000,
0.500000, 0.500000, 0.500000,
-0.500000, 0.500000, 0.500000,
-0.500000, -0.500000, 0.500000,
0.500000, -0.500000, -0.500000,
0.500000, 0.500000, -0.500000,
0.500000, 0.500000, 0.500000f,
0.500000, -0.500000, 0.500000f
0.500000, 0.500000, 0.500000,
0.500000, 0.500000, -0.500000,
-0.500000, 0.500000, -0.500000,
-0.500000, 0.500000, 0.500000,
0.500000, -0.500000, 0.500000,
0.500000, 0.500000, 0.500000,
-0.500000, 0.500000, 0.500000,
-0.500000, -0.500000, 0.500000,
0.500000, -0.500000, -0.500000,
0.500000, 0.500000, -0.500000,
0.500000, 0.500000, 0.500000f,
0.500000, -0.500000, 0.500000f
};
static const char *ObjModel =
"o 1\n"
"\n"
"# Vertex list\n"
"\n"
"v -0.5 -0.5 0.5\n"
"v -0.5 -0.5 -0.5\n"
"v -0.5 0.5 -0.5\n"
"v -0.5 0.5 0.5\n"
"v 0.5 -0.5 0.5\n"
"v 0.5 -0.5 -0.5\n"
"v 0.5 0.5 -0.5\n"
"v 0.5 0.5 0.5\n"
"\n"
"# Point / Line / Face list\n"
"\n"
"g Box01\n"
"usemtl Default\n"
"f 4 3 2 1\n"
"f 2 6 5 1\n"
"f 3 7 6 2\n"
"f 8 7 3 4\n"
"f 5 8 4 1\n"
"f 6 7 8 5\n"
"\n"
"# End of file\n";
"o 1\n"
"\n"
"# Vertex list\n"
"\n"
"v -0.5 -0.5 0.5\n"
"v -0.5 -0.5 -0.5\n"
"v -0.5 0.5 -0.5\n"
"v -0.5 0.5 0.5\n"
"v 0.5 -0.5 0.5\n"
"v 0.5 -0.5 -0.5\n"
"v 0.5 0.5 -0.5\n"
"v 0.5 0.5 0.5\n"
"\n"
"# Point / Line / Face list\n"
"\n"
"g Box01\n"
"usemtl Default\n"
"f 4 3 2 1\n"
"f 2 6 5 1\n"
"f 3 7 6 2\n"
"f 8 7 3 4\n"
"f 5 8 4 1\n"
"f 6 7 8 5\n"
"\n"
"# End of file\n";
static const char *ObjModel_Issue1111 =
"o 1\n"
"\n"
"# Vertex list\n"
"\n"
"v -0.5 -0.5 0.5\n"
"v -0.5 -0.5 -0.5\n"
"v -0.5 0.5 -0.5\n"
"\n"
"usemtl\n"
"f 1 2 3\n"
"\n"
"# End of file\n";
"o 1\n"
"\n"
"# Vertex list\n"
"\n"
"v -0.5 -0.5 0.5\n"
"v -0.5 -0.5 -0.5\n"
"v -0.5 0.5 -0.5\n"
"\n"
"usemtl\n"
"f 1 2 3\n"
"\n"
"# End of file\n";
class utObjImportExport : public AbstractImportExportBase {
protected:
@ -133,68 +133,68 @@ protected:
aiScene *createScene() {
aiScene *expScene = new aiScene;
expScene->mNumMeshes = 1;
expScene->mMeshes = new aiMesh*[ 1 ];
expScene->mMeshes = new aiMesh *[1];
aiMesh *mesh = new aiMesh;
mesh->mName.Set( "1" );
mesh->mName.Set("1");
mesh->mNumVertices = 24;
mesh->mVertices = new aiVector3D[ 24 ];
::memcpy( &mesh->mVertices->x, &VertComponents[ 0 ], sizeof( float ) * 24 * 3 );
mesh->mVertices = new aiVector3D[24];
::memcpy(&mesh->mVertices->x, &VertComponents[0], sizeof(float) * 24 * 3);
mesh->mNumFaces = 6;
mesh->mFaces = new aiFace[ mesh->mNumFaces ];
mesh->mFaces = new aiFace[mesh->mNumFaces];
mesh->mFaces[ 0 ].mNumIndices = 4;
mesh->mFaces[ 0 ].mIndices = new unsigned int[ mesh->mFaces[ 0 ].mNumIndices ];
mesh->mFaces[ 0 ].mIndices[ 0 ] = 0;
mesh->mFaces[ 0 ].mIndices[ 1 ] = 1;
mesh->mFaces[ 0 ].mIndices[ 2 ] = 2;
mesh->mFaces[ 0 ].mIndices[ 3 ] = 3;
mesh->mFaces[0].mNumIndices = 4;
mesh->mFaces[0].mIndices = new unsigned int[mesh->mFaces[0].mNumIndices];
mesh->mFaces[0].mIndices[0] = 0;
mesh->mFaces[0].mIndices[1] = 1;
mesh->mFaces[0].mIndices[2] = 2;
mesh->mFaces[0].mIndices[3] = 3;
mesh->mFaces[ 1 ].mNumIndices = 4;
mesh->mFaces[ 1 ].mIndices = new unsigned int[ mesh->mFaces[ 0 ].mNumIndices ];
mesh->mFaces[ 1 ].mIndices[ 0 ] = 4;
mesh->mFaces[ 1 ].mIndices[ 1 ] = 5;
mesh->mFaces[ 1 ].mIndices[ 2 ] = 6;
mesh->mFaces[ 1 ].mIndices[ 3 ] = 7;
mesh->mFaces[1].mNumIndices = 4;
mesh->mFaces[1].mIndices = new unsigned int[mesh->mFaces[0].mNumIndices];
mesh->mFaces[1].mIndices[0] = 4;
mesh->mFaces[1].mIndices[1] = 5;
mesh->mFaces[1].mIndices[2] = 6;
mesh->mFaces[1].mIndices[3] = 7;
mesh->mFaces[ 2 ].mNumIndices = 4;
mesh->mFaces[ 2 ].mIndices = new unsigned int[ mesh->mFaces[ 0 ].mNumIndices ];
mesh->mFaces[ 2 ].mIndices[ 0 ] = 8;
mesh->mFaces[ 2 ].mIndices[ 1 ] = 9;
mesh->mFaces[ 2 ].mIndices[ 2 ] = 10;
mesh->mFaces[ 2 ].mIndices[ 3 ] = 11;
mesh->mFaces[2].mNumIndices = 4;
mesh->mFaces[2].mIndices = new unsigned int[mesh->mFaces[0].mNumIndices];
mesh->mFaces[2].mIndices[0] = 8;
mesh->mFaces[2].mIndices[1] = 9;
mesh->mFaces[2].mIndices[2] = 10;
mesh->mFaces[2].mIndices[3] = 11;
mesh->mFaces[ 3 ].mNumIndices = 4;
mesh->mFaces[ 3 ].mIndices = new unsigned int[ mesh->mFaces[ 0 ].mNumIndices ];
mesh->mFaces[ 3 ].mIndices[ 0 ] = 12;
mesh->mFaces[ 3 ].mIndices[ 1 ] = 13;
mesh->mFaces[ 3 ].mIndices[ 2 ] = 14;
mesh->mFaces[ 3 ].mIndices[ 3 ] = 15;
mesh->mFaces[3].mNumIndices = 4;
mesh->mFaces[3].mIndices = new unsigned int[mesh->mFaces[0].mNumIndices];
mesh->mFaces[3].mIndices[0] = 12;
mesh->mFaces[3].mIndices[1] = 13;
mesh->mFaces[3].mIndices[2] = 14;
mesh->mFaces[3].mIndices[3] = 15;
mesh->mFaces[ 4 ].mNumIndices = 4;
mesh->mFaces[ 4 ].mIndices = new unsigned int[ mesh->mFaces[ 0 ].mNumIndices ];
mesh->mFaces[ 4 ].mIndices[ 0 ] = 16;
mesh->mFaces[ 4 ].mIndices[ 1 ] = 17;
mesh->mFaces[ 4 ].mIndices[ 2 ] = 18;
mesh->mFaces[ 4 ].mIndices[ 3 ] = 19;
mesh->mFaces[4].mNumIndices = 4;
mesh->mFaces[4].mIndices = new unsigned int[mesh->mFaces[0].mNumIndices];
mesh->mFaces[4].mIndices[0] = 16;
mesh->mFaces[4].mIndices[1] = 17;
mesh->mFaces[4].mIndices[2] = 18;
mesh->mFaces[4].mIndices[3] = 19;
mesh->mFaces[ 5 ].mNumIndices = 4;
mesh->mFaces[ 5 ].mIndices = new unsigned int[ mesh->mFaces[ 0 ].mNumIndices ];
mesh->mFaces[ 5 ].mIndices[ 0 ] = 20;
mesh->mFaces[ 5 ].mIndices[ 1 ] = 21;
mesh->mFaces[ 5 ].mIndices[ 2 ] = 22;
mesh->mFaces[ 5 ].mIndices[ 3 ] = 23;
mesh->mFaces[5].mNumIndices = 4;
mesh->mFaces[5].mIndices = new unsigned int[mesh->mFaces[0].mNumIndices];
mesh->mFaces[5].mIndices[0] = 20;
mesh->mFaces[5].mIndices[1] = 21;
mesh->mFaces[5].mIndices[2] = 22;
mesh->mFaces[5].mIndices[3] = 23;
expScene->mMeshes[ 0 ] = mesh;
expScene->mMeshes[0] = mesh;
expScene->mNumMaterials = 1;
expScene->mMaterials = new aiMaterial*[ expScene->mNumMaterials ];
expScene->mMaterials = new aiMaterial *[expScene->mNumMaterials];
return expScene;
}
virtual bool importerTest() {
::Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure );
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure);
return nullptr != scene;
}
@ -203,10 +203,10 @@ protected:
virtual bool exporterTest() {
::Assimp::Importer importer;
::Assimp::Exporter exporter;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure );
EXPECT_NE( nullptr, scene );
EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "obj", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_out.obj" ) );
EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "objnomtl", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_nomtl_out.obj" ) );
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene);
EXPECT_EQ(aiReturn_SUCCESS, exporter.Export(scene, "obj", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_out.obj"));
EXPECT_EQ(aiReturn_SUCCESS, exporter.Export(scene, "objnomtl", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_nomtl_out.obj"));
return true;
}
@ -218,30 +218,29 @@ protected:
aiScene *m_expectedScene;
};
TEST_F( utObjImportExport, importObjFromFileTest ) {
EXPECT_TRUE( importerTest() );
TEST_F(utObjImportExport, importObjFromFileTest) {
EXPECT_TRUE(importerTest());
}
#ifndef ASSIMP_BUILD_NO_EXPORT
TEST_F( utObjImportExport, exportObjFromFileTest ) {
EXPECT_TRUE( exporterTest() );
TEST_F(utObjImportExport, exportObjFromFileTest) {
EXPECT_TRUE(exporterTest());
}
#endif // ASSIMP_BUILD_NO_EXPORT
TEST_F( utObjImportExport, obj_import_test ) {
const aiScene *scene = m_im->ReadFileFromMemory( (void*) ObjModel, strlen(ObjModel), 0 );
TEST_F(utObjImportExport, obj_import_test) {
const aiScene *scene = m_im->ReadFileFromMemory((void *)ObjModel, strlen(ObjModel), 0);
aiScene *expected = createScene();
EXPECT_NE( nullptr, scene );
EXPECT_NE(nullptr, scene);
SceneDiffer differ;
EXPECT_TRUE( differ.isEqual( expected, scene ) );
EXPECT_TRUE(differ.isEqual(expected, scene));
differ.showReport();
m_im->FreeScene();
for(unsigned int i = 0; i < expected->mNumMeshes; ++i)
{
for (unsigned int i = 0; i < expected->mNumMeshes; ++i) {
delete expected->mMeshes[i];
}
delete[] expected->mMeshes;
@ -251,70 +250,70 @@ TEST_F( utObjImportExport, obj_import_test ) {
delete expected;
}
TEST_F( utObjImportExport, issue1111_no_mat_name_Test ) {
const aiScene *scene = m_im->ReadFileFromMemory( ( void* ) ObjModel_Issue1111, strlen(ObjModel_Issue1111), 0 );
EXPECT_NE( nullptr, scene );
TEST_F(utObjImportExport, issue1111_no_mat_name_Test) {
const aiScene *scene = m_im->ReadFileFromMemory((void *)ObjModel_Issue1111, strlen(ObjModel_Issue1111), 0);
EXPECT_NE(nullptr, scene);
}
TEST_F( utObjImportExport, issue809_vertex_color_Test ) {
TEST_F(utObjImportExport, issue809_vertex_color_Test) {
::Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/cube_with_vertexcolors.obj", aiProcess_ValidateDataStructure );
EXPECT_NE( nullptr, scene );
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/cube_with_vertexcolors.obj", aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene);
#ifndef ASSIMP_BUILD_NO_EXPORT
::Assimp::Exporter exporter;
EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "obj", ASSIMP_TEST_MODELS_DIR "/OBJ/test_out.obj" ) );
EXPECT_EQ(aiReturn_SUCCESS, exporter.Export(scene, "obj", ASSIMP_TEST_MODELS_DIR "/OBJ/test_out.obj"));
#endif // ASSIMP_BUILD_NO_EXPORT
}
TEST_F( utObjImportExport, issue1923_vertex_color_Test ) {
TEST_F(utObjImportExport, issue1923_vertex_color_Test) {
::Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/cube_with_vertexcolors_uni.obj", aiProcess_ValidateDataStructure );
EXPECT_NE( nullptr, scene );
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/cube_with_vertexcolors_uni.obj", aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene);
scene = importer.GetOrphanedScene();
#ifndef ASSIMP_BUILD_NO_EXPORT
::Assimp::Exporter exporter;
const aiExportDataBlob* blob = exporter.ExportToBlob( scene, "obj");
EXPECT_NE( nullptr, blob );
const aiExportDataBlob *blob = exporter.ExportToBlob(scene, "obj");
EXPECT_NE(nullptr, blob);
const aiScene *sceneReImport = importer.ReadFileFromMemory( blob->data, blob->size, aiProcess_ValidateDataStructure );
EXPECT_NE( nullptr, scene );
const aiScene *sceneReImport = importer.ReadFileFromMemory(blob->data, blob->size, aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene);
SceneDiffer differ;
EXPECT_TRUE( differ.isEqual( scene, sceneReImport ) );
EXPECT_TRUE(differ.isEqual(scene, sceneReImport));
#endif // ASSIMP_BUILD_NO_EXPORT
delete scene;
}
TEST_F( utObjImportExport, issue1453_segfault ) {
static const char *ObjModel =
"v 0.0 0.0 0.0\n"
"v 0.0 0.0 1.0\n"
"v 0.0 1.0 0.0\n"
"v 0.0 1.0 1.0\n"
"v 1.0 0.0 0.0\n"
"v 1.0 0.0 1.0\n"
"v 1.0 1.0 0.0\n"
"v 1.0 1.0 1.0\nB";
TEST_F(utObjImportExport, issue1453_segfault) {
static const char *curObjModel =
"v 0.0 0.0 0.0\n"
"v 0.0 0.0 1.0\n"
"v 0.0 1.0 0.0\n"
"v 0.0 1.0 1.0\n"
"v 1.0 0.0 0.0\n"
"v 1.0 0.0 1.0\n"
"v 1.0 1.0 0.0\n"
"v 1.0 1.0 1.0\nB";
Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory( ObjModel, strlen(ObjModel), aiProcess_ValidateDataStructure );
EXPECT_EQ( nullptr, scene );
const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_EQ(nullptr, scene);
}
TEST_F(utObjImportExport, relative_indices_Test) {
static const char *ObjModel =
"v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n"
"v -0.500000 1.000000 0.400000\n"
"f -4 -3 -2 -1\nB";
static const char *curObjModel =
"v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n"
"v -0.500000 1.000000 0.400000\n"
"f -4 -3 -2 -1\nB";
Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(ObjModel, strlen(ObjModel), aiProcess_ValidateDataStructure);
const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene);
EXPECT_EQ(scene->mNumMeshes, 1U);
@ -323,22 +322,20 @@ TEST_F(utObjImportExport, relative_indices_Test) {
EXPECT_EQ(mesh->mNumFaces, 1U);
const aiFace face = mesh->mFaces[0];
EXPECT_EQ(face.mNumIndices, 4U);
for (unsigned int i = 0; i < face.mNumIndices; ++i)
{
for (unsigned int i = 0; i < face.mNumIndices; ++i) {
EXPECT_EQ(face.mIndices[i], i);
}
}
TEST_F(utObjImportExport, homogeneous_coordinates_Test) {
static const char *ObjModel =
"v -0.500000 0.000000 0.400000 0.50000\n"
"v -0.500000 0.000000 -0.800000 1.00000\n"
"v 0.500000 1.000000 -0.800000 0.5000\n"
"f 1 2 3\nB";
static const char *curObjModel =
"v -0.500000 0.000000 0.400000 0.50000\n"
"v -0.500000 0.000000 -0.800000 1.00000\n"
"v 0.500000 1.000000 -0.800000 0.5000\n"
"f 1 2 3\nB";
Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(ObjModel, strlen(ObjModel), aiProcess_ValidateDataStructure);
const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_NE(nullptr, scene);
EXPECT_EQ(scene->mNumMeshes, 1U);
@ -354,84 +351,84 @@ TEST_F(utObjImportExport, homogeneous_coordinates_Test) {
}
TEST_F(utObjImportExport, homogeneous_coordinates_divide_by_zero_Test) {
static const char *ObjModel =
"v -0.500000 0.000000 0.400000 0.\n"
"v -0.500000 0.000000 -0.800000 1.00000\n"
"v 0.500000 1.000000 -0.800000 0.5000\n"
"f 1 2 3\nB";
static const char *curObjModel =
"v -0.500000 0.000000 0.400000 0.\n"
"v -0.500000 0.000000 -0.800000 1.00000\n"
"v 0.500000 1.000000 -0.800000 0.5000\n"
"f 1 2 3\nB";
Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(ObjModel, strlen(ObjModel), aiProcess_ValidateDataStructure);
EXPECT_EQ(nullptr, scene);
Assimp::Importer myimporter;
const aiScene *scene = myimporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), aiProcess_ValidateDataStructure);
EXPECT_EQ(nullptr, scene);
}
TEST_F(utObjImportExport, 0based_array_Test) {
static const char *ObjModel =
"v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n"
"f 0 1 2\nB";
static const char *curObjModel =
"v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n"
"f 0 1 2\nB";
Assimp::Importer myImporter;
const aiScene *scene = myImporter.ReadFileFromMemory(ObjModel, strlen(ObjModel), 0);
const aiScene *scene = myImporter.ReadFileFromMemory(curObjModel, strlen(curObjModel), 0);
EXPECT_EQ(nullptr, scene);
}
TEST_F(utObjImportExport, invalid_normals_uvs) {
static const char *ObjModel =
"v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n"
"vt 0 0\n"
"vn 0 1 0\n"
"f 1/1/1 1/1/1 2/2/2\nB";
static const char *curObjModel =
"v -0.500000 0.000000 0.400000\n"
"v -0.500000 0.000000 -0.800000\n"
"v -0.500000 1.000000 -0.800000\n"
"vt 0 0\n"
"vn 0 1 0\n"
"f 1/1/1 1/1/1 2/2/2\nB";
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);
}
TEST_F(utObjImportExport, no_vt_just_vns) {
static const char *ObjModel =
"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"
"v 0 0 0\n"
"v 0 0 0\n"
"v 0 0 0\n"
"v 0 0 0\n"
"v 10 0 0\n"
"v 0 10 0\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"f 10/10 11/11 12/12\n";
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"
"v 0 0 0\n"
"v 0 0 0\n"
"v 0 0 0\n"
"v 0 0 0\n"
"v 10 0 0\n"
"v 0 10 0\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"vn 0 0 1\n"
"f 10/10 11/11 12/12\n";
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);
}
TEST_F( utObjImportExport, mtllib_after_g ) {
TEST_F(utObjImportExport, mtllib_after_g) {
::Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/cube_mtllib_after_g.obj", aiProcess_ValidateDataStructure );
ASSERT_NE( nullptr, scene );
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/cube_mtllib_after_g.obj", aiProcess_ValidateDataStructure);
ASSERT_NE(nullptr, scene);
EXPECT_EQ(scene->mNumMeshes, 1U);
const aiMesh *mesh = scene->mMeshes[0];
const aiMaterial* mat = scene->mMaterials[mesh->mMaterialIndex];
const aiMaterial *mat = scene->mMaterials[mesh->mMaterialIndex];
aiString name;
ASSERT_EQ(aiReturn_SUCCESS, mat->Get(AI_MATKEY_NAME, name));
EXPECT_STREQ("MyMaterial", name.C_Str());
@ -439,7 +436,7 @@ TEST_F( utObjImportExport, mtllib_after_g ) {
TEST_F(utObjImportExport, import_point_cloud) {
::Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/point_cloud.obj", 0 );
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/point_cloud.obj", 0);
ASSERT_NE(nullptr, scene);
}
@ -450,17 +447,17 @@ TEST_F(utObjImportExport, import_without_linend) {
}
TEST_F(utObjImportExport, import_with_line_continuations) {
static const char *ObjModel =
"v -0.5 -0.5 0.5\n"
"v -0.5 \\\n"
" -0.5 -0.5\n"
"v -0.5 \\\n"
" 0.5 \\\n"
" -0.5\n"
"f 1 2 3\n";
static const char *curObjModel =
"v -0.5 -0.5 0.5\n"
"v -0.5 \\\n"
" -0.5 -0.5\n"
"v -0.5 \\\n"
" 0.5 \\\n"
" -0.5\n"
"f 1 2 3\n";
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_EQ(scene->mNumMeshes, 1U);

2
test/unit/utSortByPType.cpp
View File

@ -183,7 +183,7 @@ TEST_F(SortByPTypeProcessTest, SortByPTypeStep) {
unsigned int idx = 0;
for (unsigned int m = 0,real = 0; m< 10;++m) {
for (unsigned int n = 0; n < 4;++n) {
idx = num[m][n])
idx = num[m][n];
if (idx) {
EXPECT_TRUE(real < mScene->mNumMeshes);

8
test/unit/utTriangulate.cpp
View File

@ -112,11 +112,11 @@ TEST_F(TriangulateProcessTest, testTriangulation) {
std::vector<bool> ait(q,false);
for (unsigned int i = 0, tt = q-2; i < tt; ++i,++m) {
aiFace& face = pcMesh->mFaces[m];
EXPECT_EQ(3U, face.mNumIndices);
aiFace& curFace = pcMesh->mFaces[m];
EXPECT_EQ(3U, curFace.mNumIndices);
for (unsigned int qqq = 0; qqq < face.mNumIndices; ++qqq) {
ait[face.mIndices[qqq]-idx] = true;
for (unsigned int qqq = 0; qqq < curFace.mNumIndices; ++qqq) {
ait[curFace.mIndices[qqq] - idx] = true;
}
}
for (std::vector<bool>::const_iterator it = ait.begin(); it != ait.end(); ++it) {

193
tools/assimp_cmd/Export.cpp
View File

@ -46,129 +46,122 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Main.h"
#include <assimp/ParsingUtils.h>
#ifndef ASSIMP_BUILD_NO_EXPORT
const char* AICMD_MSG_EXPORT_HELP_E =
"assimp export <model> [<out>] [-f<h>] [common parameters]\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[See the assimp_cmd docs for a full list of all common parameters] \n"
;
const char *AICMD_MSG_EXPORT_HELP_E =
"assimp export <model> [<out>] [-f<h>] [common parameters]\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[See the assimp_cmd docs for a full list of all common parameters] \n";
// -----------------------------------------------------------------------------------
size_t GetMatchingFormat(const std::string& outf,bool byext=false)
{
for(size_t i = 0, end = globalExporter->GetExportFormatCount(); i < end; ++i) {
const aiExportFormatDesc* const e = globalExporter->GetExportFormatDescription(i);
if (outf == (byext ? e->fileExtension : e->id)) {
return i;
}
}
return SIZE_MAX;
size_t GetMatchingFormat(const std::string &outf, bool byext = false) {
for (size_t i = 0, end = globalExporter->GetExportFormatCount(); i < end; ++i) {
const aiExportFormatDesc *const e = globalExporter->GetExportFormatDescription(i);
if (outf == (byext ? e->fileExtension : e->id)) {
return i;
}
}
return SIZE_MAX;
}
// -----------------------------------------------------------------------------------
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";
if (num < 1) {
printf(invalid);
return AssimpCmdError::InvalidNumberOfArguments;
}
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";
if (num < 1) {
printf(invalid);
return AssimpCmdError::InvalidNumberOfArguments;
}
// --help
if (!strcmp( params[0], "-h") || !strcmp( params[0], "--help") || !strcmp( params[0], "-?") ) {
printf("%s",AICMD_MSG_EXPORT_HELP_E);
return AssimpCmdError::Success;
}
// --help
if (!strcmp(params[0], "-h") || !strcmp(params[0], "--help") || !strcmp(params[0], "-?")) {
printf("%s", AICMD_MSG_EXPORT_HELP_E);
return AssimpCmdError::Success;
}
std::string in = std::string(params[0]);
std::string out = (num > 1 ? std::string(params[1]) : "-"), outext;
std::string in = std::string(params[0]);
std::string out = (num > 1 ? std::string(params[1]) : "-"), outext;
//
const std::string::size_type s = out.find_last_of('.');
if (s != std::string::npos) {
outext = out.substr(s+1);
out = out.substr(0,s);
}
//
const std::string::size_type s = out.find_last_of('.');
if (s != std::string::npos) {
outext = out.substr(s + 1);
out = out.substr(0, s);
}
// get import flags
ImportData import;
ProcessStandardArguments(import,params+1,num-1);
// get import flags
ImportData import;
ProcessStandardArguments(import, params + 1, num - 1);
// process other flags
std::string outf = "";
for (unsigned int i = (out[0] == '-' ? 1 : 2); i < num;++i) {
if (!params[i]) {
continue;
}
if (!strncmp( params[i], "-f",2)) {
if ( strncmp( params[ i ], "-fi",3 ))
outf = std::string(params[i]+2);
}
else if ( !strncmp( params[i], "--format=",9)) {
outf = std::string(params[i]+9);
}
}
// process other flags
std::string outf = "";
for (unsigned int i = (out[0] == '-' ? 1 : 2); i < num; ++i) {
if (!params[i]) {
continue;
}
if (!strncmp(params[i], "-f", 2)) {
if (strncmp(params[i], "-fi", 3))
outf = std::string(params[i] + 2);
} else if (!strncmp(params[i], "--format=", 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
size_t outfi = GetMatchingFormat(outf);
if (outfi == SIZE_MAX) {
if (outf.length()) {
printf("assimp export: warning, format id \'%s\' is unknown\n",outf.c_str());
}
// convert the output format to a format id
size_t outfi = GetMatchingFormat(outf);
if (outfi == SIZE_MAX) {
if (outf.length()) {
printf("assimp export: warning, format id \'%s\' is unknown\n", outf.c_str());
}
// retry to see if we know it as file extension
outfi = GetMatchingFormat(outf,true);
if (outfi == SIZE_MAX) {
// retry to see if we know the file extension of the output file
outfi = GetMatchingFormat(outext,true);
// retry to see if we know it as file extension
outfi = GetMatchingFormat(outf, true);
if (outfi == SIZE_MAX) {
// retry to see if we know the file extension of the output file
outfi = GetMatchingFormat(outext, true);
if (outfi == SIZE_MAX) {
// still no match -> failure
printf("assimp export: no output format specified and I failed to guess it\n");
return -23;
}
}
else {
outext = outf;
}
}
if (outfi == SIZE_MAX) {
// still no match -> failure
printf("assimp export: no output format specified and I failed to guess it\n");
return -23;
}
} else {
outext = outf;
}
}
// if no output file is specified, take the file name from input file
if (out[0] == '-') {
std::string::size_type s = in.find_last_of('.');
if (s == std::string::npos) {
s = in.length();
}
// if no output file is specified, take the file name from input file
if (out[0] == '-') {
std::string::size_type pos = in.find_last_of('.');
if (pos == std::string::npos) {
pos = in.length();
}
out = in.substr(0,s);
}
out = in.substr(0, pos);
}
const aiExportFormatDesc* const e = globalExporter->GetExportFormatDescription(outfi);
printf("assimp export: select file format: \'%s\' (%s)\n",e->id,e->description);
const aiExportFormatDesc *const e = globalExporter->GetExportFormatDescription(outfi);
printf("assimp export: select file format: \'%s\' (%s)\n", e->id, e->description);
// import the model
const aiScene* scene = ImportModel(import,in);
if (!scene) {
return AssimpCmdExportError::FailedToImportModel;
}
// import the model
const aiScene *scene = ImportModel(import, in);
if (!scene) {
return AssimpCmdExportError::FailedToImportModel;
}
// derive the final file name
out += "."+outext;
// derive the final file name
out += "." + outext;
// and call the export routine
if(!ExportModel(scene, import, out,e->id)) {
return AssimpCmdExportError::FailedToExportModel;
}
printf("assimp export: wrote output file: %s\n",out.c_str());
return AssimpCmdError::Success;
// and call the export routine
if (!ExportModel(scene, import, out, e->id)) {
return AssimpCmdExportError::FailedToExportModel;
}
printf("assimp export: wrote output file: %s\n", out.c_str());
return AssimpCmdError::Success;
}
#endif // no export

255
tools/assimp_cmd/ImageExtractor.cpp
View File

@ -5,8 +5,6 @@ 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,
@ -46,94 +44,89 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Main.h"
#include <assimp/fast_atof.h>
#include <assimp/ParsingUtils.h>
#include <assimp/StringComparison.h>
#include <assimp/fast_atof.h>
const char* AICMD_MSG_DUMP_HELP_E =
"assimp extract <model> [<out>] [-t<n>] [-f<fmt>] [-ba] [-s] [common parameters]\n"
"\t -ba Writes BMP's with alpha channel\n"
"\t -t<n> Zero-based index of the texture to be extracted \n"
"\t -f<f> Specify the file format if <out> is omitted \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 -cdefault Default post processing: runs all recommended steps\n"
"\t -cfull Fires almost all post processing steps \n"
;
static const char *AICMD_MSG_DUMP_HELP_E =
"assimp extract <model> [<out>] [-t<n>] [-f<fmt>] [-ba] [-s] [common parameters]\n"
"\t -ba Writes BMP's with alpha channel\n"
"\t -t<n> Zero-based index of the texture to be extracted \n"
"\t -f<f> Specify the file format if <out> is omitted \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 -cdefault Default post processing: runs all recommended steps\n"
"\t -cfull Fires almost all post processing steps \n";
#define AI_EXTRACT_WRITE_BMP_ALPHA 0x1
#include <assimp/Compiler/pushpack1.h>
// -----------------------------------------------------------------------------------
// Data structure for the first header of a BMP
struct BITMAPFILEHEADER
{
uint16_t bfType ;
uint32_t bfSize;
uint16_t bfReserved1 ;
uint16_t bfReserved2;
uint32_t bfOffBits;
struct BITMAPFILEHEADER {
uint16_t bfType;
uint32_t bfSize;
uint16_t bfReserved1;
uint16_t bfReserved2;
uint32_t bfOffBits;
} PACK_STRUCT;
// -----------------------------------------------------------------------------------
// Data structure for the second header of a BMP
struct BITMAPINFOHEADER
{
int32_t biSize;
int32_t biWidth;
int32_t biHeight;
int16_t biPlanes;
int16_t biBitCount;
uint32_t biCompression;
int32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
int32_t biClrUsed;
int32_t biClrImportant;
struct BITMAPINFOHEADER {
int32_t biSize;
int32_t biWidth;
int32_t biHeight;
int16_t biPlanes;
int16_t biBitCount;
uint32_t biCompression;
int32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
int32_t biClrUsed;
int32_t biClrImportant;
// pixel data follows header
} PACK_STRUCT;
// -----------------------------------------------------------------------------------
// Data structure for the header of a TGA
struct TGA_HEADER
{
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 imagetype; // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed
struct TGA_HEADER {
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 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 colourmaplength; // number of colours in palette
uint8_t colourmapbits; // number of bits per palette entry 15,16,24,32
uint16_t colourmapstart; // first colour map entry in palette
uint16_t colourmaplength; // number of colors in palette
uint8_t colourmapbits; // number of bits per palette entry 15,16,24,32
uint16_t xstart; // image x origin
uint16_t ystart; // image y origin
uint16_t width; // image width in pixels
uint16_t height; // image height in pixels
uint8_t bits; // image bits per pixel 8,16,24,32
uint8_t descriptor; // image descriptor bits (vh flip bits)
uint16_t xstart; // image x origin
uint16_t ystart; // image y origin
uint16_t width; // image width in pixels
uint16_t height; // image height in pixels
uint8_t bits; // image bits per pixel 8,16,24,32
uint8_t descriptor; // image descriptor bits (vh flip bits)
// pixel data follows header
} PACK_STRUCT;
#include <assimp/Compiler/poppack1.h>
// -----------------------------------------------------------------------------------
// 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) {
return 1;
}
const unsigned int numc = (SaveAlpha ? 4 : 3);
unsigned char* buffer = new unsigned char[width*height*numc];
unsigned char *buffer = new unsigned char[width * height * numc];
for (unsigned int y = 0; y < height; ++y) {
for (unsigned int x = 0; x < width; ++x) {
unsigned char* s = &buffer[(y*width+x) * numc];
const aiTexel* t = &data [ y*width+x];
unsigned char *s = &buffer[(y * width + x) * numc];
const aiTexel *t = &data[y * width + x];
s[0] = t->b;
s[1] = t->g;
s[2] = t->r;
@ -143,33 +136,33 @@ int SaveAsBMP (FILE* file, const aiTexel* data, unsigned int width, unsigned int
}
BITMAPFILEHEADER header;
header.bfType = 'B' | (int('M') << 8u);
header.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
header.bfSize = header.bfOffBits+width*height*numc;
header.bfType = 'B' | (int('M') << 8u);
header.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
header.bfSize = header.bfOffBits + width * height * numc;
header.bfReserved1 = header.bfReserved2 = 0;
fwrite(&header,sizeof(BITMAPFILEHEADER),1,file);
fwrite(&header, sizeof(BITMAPFILEHEADER), 1, file);
BITMAPINFOHEADER info;
info.biSize = 40;
info.biWidth = width;
info.biHeight = height;
info.biPlanes = 1;
info.biBitCount = numc<<3;
info.biSize = 40;
info.biWidth = width;
info.biHeight = height;
info.biPlanes = 1;
info.biBitCount = (int16_t)numc << 3;
info.biCompression = 0;
info.biSizeImage = width*height*numc;
info.biSizeImage = width * height * numc;
info.biXPelsPerMeter = 1; // dummy
info.biYPelsPerMeter = 1; // dummy
info.biClrUsed = 0;
info.biClrImportant = 0;
fwrite(&info,sizeof(BITMAPINFOHEADER),1,file);
fwrite(&info, sizeof(BITMAPINFOHEADER), 1, file);
unsigned char* temp = buffer+info.biSizeImage;
const unsigned int row = width*numc;
unsigned char *temp = buffer + info.biSizeImage;
const unsigned int row = width * numc;
for (int y = 0; temp -= row,y < info.biHeight;++y) {
fwrite(temp,row,1,file);
for (int y = 0; temp -= row, y < info.biHeight; ++y) {
fwrite(temp, row, 1, file);
}
// delete the buffer
@ -179,25 +172,24 @@ int SaveAsBMP (FILE* file, const aiTexel* data, unsigned int width, unsigned int
// -----------------------------------------------------------------------------------
// 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) {
return 1;
}
TGA_HEADER head;
memset(&head, 0, sizeof(head));
head.bits = 32;
head.bits = 32;
head.height = (uint16_t)height;
head.width = (uint16_t)width;
head.descriptor |= (1u<<5);
head.width = (uint16_t)width;
head.descriptor |= (1u << 5);
head.imagetype = 2; // actually it's RGBA
fwrite(&head,sizeof(TGA_HEADER),1,file);
fwrite(&head, sizeof(TGA_HEADER), 1, file);
for (unsigned int y = 0; y < height; ++y) {
for (unsigned int x = 0; x < width; ++x) {
fwrite(data + y*width+x,4,1,file);
fwrite(data + y * width + x, 4, 1, file);
}
}
@ -206,18 +198,15 @@ int SaveAsTGA (FILE* file, const aiTexel* data, unsigned int width, unsigned int
// -----------------------------------------------------------------------------------
// Do the texture import for a given aiTexture
int DoExport(const aiTexture* tx, FILE* p, const std::string& extension,
unsigned int flags)
{
int DoExport(const aiTexture *tx, FILE *p, const std::string &extension,
unsigned int flags) {
// export the image to the appropriate decoder
if (extension == "bmp") {
SaveAsBMP(p,tx->pcData,tx->mWidth,tx->mHeight,
(0 != (flags & AI_EXTRACT_WRITE_BMP_ALPHA)));
}
else if (extension == "tga") {
SaveAsTGA(p,tx->pcData,tx->mWidth,tx->mHeight);
}
else {
SaveAsBMP(p, tx->pcData, tx->mWidth, tx->mHeight,
(0 != (flags & AI_EXTRACT_WRITE_BMP_ALPHA)));
} else if (extension == "tga") {
SaveAsTGA(p, tx->pcData, tx->mWidth, tx->mHeight);
} else {
printf("assimp extract: No available texture encoder found for %s\n", extension.c_str());
return AssimpCmdExtractError::NoAvailableTextureEncoderFound;
}
@ -226,9 +215,8 @@ int DoExport(const aiTexture* tx, FILE* p, const std::string& extension,
// -----------------------------------------------------------------------------------
// Implementation of the assimp extract utility
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";
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";
// assimp extract in out [options]
if (num < 1) {
printf(invalid);
@ -236,46 +224,39 @@ int Assimp_Extract (const char* const* params, unsigned int num)
}
// --help
if (!strcmp( params[0], "-h") || !strcmp( params[0], "--help") || !strcmp( params[0], "-?") ) {
printf("%s",AICMD_MSG_DUMP_HELP_E);
if (!strcmp(params[0], "-h") || !strcmp(params[0], "--help") || !strcmp(params[0], "-?")) {
printf("%s", AICMD_MSG_DUMP_HELP_E);
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]) : "-");
// get import flags
ImportData import;
ProcessStandardArguments(import,params+1,num-1);
ProcessStandardArguments(import, params + 1, num - 1);
bool nosuffix = false;
unsigned int texIdx = 0xffffffff, flags = 0;
unsigned int texIdx = 0xffffffff, flags = 0;
// process other flags
std::string extension = "bmp";
for (unsigned int i = (out[0] == '-' ? 1 : 2); i < num;++i) {
for (unsigned int i = (out[0] == '-' ? 1 : 2); i < num; ++i) {
if (!params[i]) {
continue;
}
if (!strncmp( params[i], "-f",2)) {
extension = std::string(params[i]+2);
}
else if ( !strncmp( params[i], "--format=",9)) {
extension = std::string(params[i]+9);
}
else if ( !strcmp( params[i], "--nosuffix") || !strcmp(params[i],"-s")) {
if (!strncmp(params[i], "-f", 2)) {
extension = std::string(params[i] + 2);
} else if (!strncmp(params[i], "--format=", 9)) {
extension = std::string(params[i] + 9);
} else if (!strcmp(params[i], "--nosuffix") || !strcmp(params[i], "-s")) {
nosuffix = true;
}
else if ( !strncmp( params[i], "--texture=",10)) {
texIdx = Assimp::strtoul10(params[i]+10);
}
else if ( !strncmp( params[i], "-t",2)) {
texIdx = Assimp::strtoul10(params[i]+2);
}
else if ( !strcmp( params[i], "-ba") || !strcmp( params[i], "--bmp-with-alpha")) {
} else if (!strncmp(params[i], "--texture=", 10)) {
texIdx = Assimp::strtoul10(params[i] + 10);
} else if (!strncmp(params[i], "-t", 2)) {
texIdx = Assimp::strtoul10(params[i] + 2);
} else if (!strcmp(params[i], "-ba") || !strcmp(params[i], "--bmp-with-alpha")) {
flags |= AI_EXTRACT_WRITE_BMP_ALPHA;
}
#if 0
@ -286,7 +267,7 @@ int Assimp_Extract (const char* const* params, unsigned int num)
#endif
}
std::transform(extension.begin(),extension.end(),extension.begin(),::tolower);
std::transform(extension.begin(), extension.end(), extension.begin(), Assimp::ToLower<char>);
if (out[0] == '-') {
// take file name from input file
@ -294,20 +275,20 @@ int Assimp_Extract (const char* const* params, unsigned int num)
if (s == std::string::npos)
s = in.length();
out = in.substr(0,s);
out = in.substr(0, s);
}
// take file extension from file name, if given
std::string::size_type s = out.find_last_of('.');
if (s != std::string::npos) {
extension = out.substr(s+1,in.length()-(s+1));
out = out.substr(0,s);
extension = out.substr(s + 1, in.length() - (s + 1));
out = out.substr(0, s);
}
// import the main model
const aiScene* scene = ImportModel(import,in);
const aiScene *scene = ImportModel(import, in);
if (!scene) {
printf("assimp extract: Unable to load input file %s\n",in.c_str());
printf("assimp extract: Unable to load input file %s\n", in.c_str());
return AssimpCmdError::FailedToLoadInputFile;
}
@ -317,28 +298,27 @@ int Assimp_Extract (const char* const* params, unsigned int num)
// check whether the requested texture is existing
if (texIdx >= scene->mNumTextures) {
::printf("assimp extract: Texture %i requested, but there are just %i textures\n",
texIdx, scene->mNumTextures);
texIdx, scene->mNumTextures);
return AssimpCmdExtractError::TextureIndexIsOutOfRange;
}
}
else {
::printf("assimp extract: Exporting %i textures\n",scene->mNumTextures);
} else {
::printf("assimp extract: Exporting %i textures\n", scene->mNumTextures);
}
// now write all output textures
for (unsigned int i = 0; i < scene->mNumTextures;++i) {
for (unsigned int i = 0; i < scene->mNumTextures; ++i) {
if (texIdx != 0xffffffff && texIdx != i) {
continue;
}
const aiTexture* tex = scene->mTextures[i];
const aiTexture *tex = scene->mTextures[i];
std::string out_cpy = out, out_ext = extension;
// append suffix if necessary - always if all textures are exported
if (!nosuffix || (texIdx == 0xffffffff)) {
out_cpy.append ("_img");
out_cpy.append("_img");
char tmp[10];
Assimp::ASSIMP_itoa10(tmp,i);
Assimp::ASSIMP_itoa10(tmp, i);
out_cpy.append(std::string(tmp));
}
@ -347,32 +327,35 @@ int Assimp_Extract (const char* const* params, unsigned int num)
// it to its native file format
if (!tex->mHeight) {
printf("assimp extract: Texture %i is compressed (%s). Writing native file format.\n",
i,tex->achFormatHint);
i, tex->achFormatHint);
// modify file extension
out_ext = std::string(tex->achFormatHint);
}
out_cpy.append("."+out_ext);
out_cpy.append("." + out_ext);
// open output file
FILE* p = ::fopen(out_cpy.c_str(),"wb");
if (!p) {
printf("assimp extract: Unable to open output file %s\n",out_cpy.c_str());
FILE *p = ::fopen(out_cpy.c_str(), "wb");
if (!p) {
printf("assimp extract: Unable to open output file %s\n", out_cpy.c_str());
return AssimpCmdError::FailedToOpenOutputFile;
}
int m;
if (!tex->mHeight) {
m = (1 != fwrite(tex->pcData,tex->mWidth,1,p))
? static_cast<int>(AssimpCmdError::Success)
: static_cast<int>(AssimpCmdExtractError::FailedToExportCompressedTexture);
m = (1 != fwrite(tex->pcData, tex->mWidth, 1, p)) ?
static_cast<int>(AssimpCmdError::Success) :
static_cast<int>(AssimpCmdExtractError::FailedToExportCompressedTexture);
} else {
m = DoExport(tex, p, extension, flags);
}
else m = DoExport(tex,p,extension,flags);
::fclose(p);
printf("assimp extract: Wrote texture %i to %s\n",i, out_cpy.c_str());
if (texIdx != 0xffffffff)
printf("assimp extract: Wrote texture %i to %s\n", i, out_cpy.c_str());
if (texIdx != 0xffffffff) {
return m;
}
}
return AssimpCmdError::Success;
}

178
tools/assimp_cmd/WriteDump.cpp
View File

@ -48,16 +48,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "Main.h"
#include "PostProcessing/ProcessHelper.h"
const char* AICMD_MSG_DUMP_HELP =
"assimp dump <model> [<out>] [-b] [-s] [-z] [common parameters]\n"
"\t -b Binary output \n"
"\t -s Shortened \n"
"\t -z Compressed \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 -cdefault Default post processing: runs all recommended steps\n"
"\t -cfull Fires almost all post processing steps \n"
;
const char *AICMD_MSG_DUMP_HELP =
"assimp dump <model> [<out>] [-b] [-s] [-z] [common parameters]\n"
"\t -b Binary output \n"
"\t -s Shortened \n"
"\t -z Compressed \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 -cdefault Default post processing: runs all recommended steps\n"
"\t -cfull Fires almost all post processing steps \n";
#include "Common/assbin_chunks.h"
#include <assimp/DefaultIOSystem.h>
@ -66,107 +65,102 @@ const char* AICMD_MSG_DUMP_HELP =
#include <memory>
FILE* out = NULL;
FILE *out = NULL;
bool shortened = false;
// -----------------------------------------------------------------------------------
int Assimp_Dump (const char* const* params, unsigned int num)
{
const char* fail = "assimp dump: Invalid number of arguments. "
"See \'assimp dump --help\'\r\n";
int Assimp_Dump(const char *const *params, unsigned int num) {
const char *fail = "assimp dump: Invalid number of arguments. "
"See \'assimp dump --help\'\r\n";
// --help
if (!strcmp( params[0], "-h") || !strcmp( params[0], "--help") || !strcmp( params[0], "-?") ) {
printf("%s",AICMD_MSG_DUMP_HELP);
return AssimpCmdError::Success;
}
// --help
if (!strcmp(params[0], "-h") || !strcmp(params[0], "--help") || !strcmp(params[0], "-?")) {
printf("%s", AICMD_MSG_DUMP_HELP);
return AssimpCmdError::Success;
}
// asssimp dump in out [options]
if (num < 1) {
printf("%s", fail);
return AssimpCmdError::InvalidNumberOfArguments;
}
// asssimp dump in out [options]
if (num < 1) {
printf("%s", fail);
return AssimpCmdError::InvalidNumberOfArguments;
}
std::string in = std::string(params[0]);
std::string out = (num > 1 ? std::string(params[1]) : std::string("-"));
std::string in = std::string(params[0]);
std::string cur_out = (num > 1 ? std::string(params[1]) : std::string("-"));
// store full command line
std::string cmd;
for (unsigned int i = (out[0] == '-' ? 1 : 2); i < num;++i) {
if (!params[i])continue;
cmd.append(params[i]);
cmd.append(" ");
}
// store full command line
std::string cmd;
for (unsigned int i = (cur_out[0] == '-' ? 1 : 2); i < num; ++i) {
if (!params[i]) continue;
cmd.append(params[i]);
cmd.append(" ");
}
// get import flags
ImportData import;
ProcessStandardArguments(import,params+1,num-1);
// get import flags
ImportData import;
ProcessStandardArguments(import, params + 1, num - 1);
bool binary = false, shortened = false,compressed=false;
bool binary = false, cur_shortened = false, compressed = false;
// process other flags
for (unsigned int i = 1; i < num;++i) {
if (!params[i])continue;
if (!strcmp( params[i], "-b") || !strcmp( params[i], "--binary")) {
binary = true;
}
else if (!strcmp( params[i], "-s") || !strcmp( params[i], "--short")) {
shortened = true;
}
else if (!strcmp( params[i], "-z") || !strcmp( params[i], "--compressed")) {
compressed = true;
}
// process other flags
for (unsigned int i = 1; i < num; ++i) {
if (!params[i]) {
continue;
}
if (!strcmp(params[i], "-b") || !strcmp(params[i], "--binary")) {
binary = true;
} else if (!strcmp(params[i], "-s") || !strcmp(params[i], "--short")) {
shortened = true;
} else if (!strcmp(params[i], "-z") || !strcmp(params[i], "--compressed")) {
compressed = true;
}
#if 0
else if (i > 2 || params[i][0] == '-') {
::printf("Unknown parameter: %s\n",params[i]);
return 10;
}
#endif
}
}
if (out[0] == '-') {
// take file name from input file
std::string::size_type s = in.find_last_of('.');
if (s == std::string::npos) {
s = in.length();
}
if (cur_out[0] == '-') {
// take file name from input file
std::string::size_type pos = in.find_last_of('.');
if (pos == std::string::npos) {
pos = in.length();
}
out = in.substr(0,s);
out.append((binary ? ".assbin" : ".assxml"));
if (shortened && binary) {
out.append(".regress");
}
}
cur_out = in.substr(0, pos);
cur_out.append((binary ? ".assbin" : ".assxml"));
if (cur_shortened && binary) {
cur_out.append(".regress");
}
}
// import the main model
const aiScene* scene = ImportModel(import,in);
if (!scene) {
printf("assimp dump: Unable to load input file %s\n",in.c_str());
return AssimpCmdError::FailedToLoadInputFile;
}
// import the main model
const aiScene *scene = ImportModel(import, in);
if (!scene) {
printf("assimp dump: Unable to load input file %s\n", in.c_str());
return AssimpCmdError::FailedToLoadInputFile;
}
try {
// Dump the main model, using the appropriate method.
std::unique_ptr<IOSystem> pIOSystem(new DefaultIOSystem());
if (binary) {
DumpSceneToAssbin(out.c_str(), cmd.c_str(), pIOSystem.get(),
scene, shortened, compressed);
}
else {
DumpSceneToAssxml(out.c_str(), cmd.c_str(), pIOSystem.get(),
scene, shortened);
}
}
catch (const std::exception& e) {
printf("%s", ("assimp dump: " + std::string(e.what())).c_str());
return AssimpCmdError::ExceptionWasRaised;
}
catch (...) {
printf("assimp dump: An unknown exception occured.\n");
return AssimpCmdError::ExceptionWasRaised;
}
try {
// Dump the main model, using the appropriate method.
std::unique_ptr<IOSystem> pIOSystem(new DefaultIOSystem());
if (binary) {
DumpSceneToAssbin(cur_out.c_str(), cmd.c_str(), pIOSystem.get(),
scene, shortened, compressed);
} else {
DumpSceneToAssxml(cur_out.c_str(), cmd.c_str(), pIOSystem.get(),
scene, shortened);
}
} catch (const std::exception &e) {
printf("%s", ("assimp dump: " + std::string(e.what())).c_str());
return AssimpCmdError::ExceptionWasRaised;
} catch (...) {
printf("assimp dump: An unknown exception occurred.\n");
return AssimpCmdError::ExceptionWasRaised;
}
printf("assimp dump: Wrote output dump %s\n",out.c_str());
return AssimpCmdError::Success;
printf("assimp dump: Wrote output dump %s\n", cur_out.c_str());
return AssimpCmdError::Success;
}