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

Merge branch 'master' into master

pull/3126/head
Kim Kulling 2020-04-06 20:42:41 +02:00 committed by GitHub
parent 9fb81c3be6 4eb129fa6d
commit 09eba0f039
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 595 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
code/Common/Assimp.cpp
View File

@ -44,15 +44,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Implementation of the Plain-C API
*/
#include <assimp/BaseImporter.h>
#include <assimp/Exceptional.h>
#include <assimp/GenericProperty.h>
#include <assimp/cimport.h>
#include <assimp/LogStream.hpp>
#include <assimp/DefaultLogger.hpp>
#include <assimp/Importer.hpp>
#include <assimp/importerdesc.h>
#include <assimp/scene.h>
#include <assimp/GenericProperty.h>
#include <assimp/Exceptional.h>
#include <assimp/BaseImporter.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/Importer.hpp>
#include <assimp/LogStream.hpp>
#include "CApi/CInterfaceIOWrapper.h"
#include "Importer.h"
@ -62,8 +62,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ------------------------------------------------------------------------------------------------
#ifndef ASSIMP_BUILD_SINGLETHREADED
# include <thread>
#include <mutex>
#include <thread>
#endif
// ------------------------------------------------------------------------------------------------
using namespace Assimp;
@ -100,8 +100,7 @@ namespace Assimp {
/** will delete all registered importers. */
void DeleteImporterInstanceList(std::vector<BaseImporter *> &out);
} // namespace assimp
} // namespace Assimp
#ifndef ASSIMP_BUILD_SINGLETHREADED
/** Global mutex to manage the access to the log-stream map */
@ -112,8 +111,8 @@ static std::mutex gLogStreamMutex;
// Custom LogStream implementation for the C-API
class LogToCallbackRedirector : public LogStream {
public:
explicit LogToCallbackRedirector(const aiLogStream& s)
: stream (s) {
explicit LogToCallbackRedirector(const aiLogStream &s) :
stream(s) {
ai_assert(NULL != s.callback);
}
@ -212,8 +211,7 @@ const aiScene* aiImportFileFromMemory(
const char *pBuffer,
unsigned int pLength,
unsigned int pFlags,
const char* pHint)
{
const char *pHint) {
return aiImportFileFromMemoryWithProperties(pBuffer, pLength, pFlags, pHint, NULL);
}
@ -223,8 +221,7 @@ const aiScene* aiImportFileFromMemoryWithProperties(
unsigned int pLength,
unsigned int pFlags,
const char *pHint,
const aiPropertyStore* props)
{
const aiPropertyStore *props) {
ai_assert(NULL != pBuffer);
ai_assert(0 != pLength);
@ -251,8 +248,7 @@ const aiScene* aiImportFileFromMemoryWithProperties(
if (scene) {
ScenePrivateData *priv = const_cast<ScenePrivateData *>(ScenePriv(scene));
priv->mOrigImporter = imp;
}
else {
} else {
// if failed, extract error code and destroy the import
gLastErrorString = imp->GetErrorString();
delete imp;
@ -264,8 +260,7 @@ const aiScene* aiImportFileFromMemoryWithProperties(
// ------------------------------------------------------------------------------------------------
// Releases all resources associated with the given import process.
void aiReleaseImport( const aiScene* pScene)
{
void aiReleaseImport(const aiScene *pScene) {
if (!pScene) {
return;
}
@ -276,8 +271,7 @@ void aiReleaseImport( const aiScene* pScene)
const ScenePrivateData *priv = ScenePriv(pScene);
if (!priv || !priv->mOrigImporter) {
delete pScene;
}
else {
} else {
// deleting the Importer also deletes the scene
// Note: the reason that this is not written as 'delete priv->mOrigImporter'
// is a suspected bug in gcc 4.4+ (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52339)
@ -290,11 +284,9 @@ void aiReleaseImport( const aiScene* pScene)
// ------------------------------------------------------------------------------------------------
ASSIMP_API const aiScene *aiApplyPostProcessing(const aiScene *pScene,
unsigned int pFlags)
{
unsigned int pFlags) {
const aiScene *sc = NULL;
ASSIMP_BEGIN_EXCEPTION_REGION();
// find the importer associated with this data
@ -343,8 +335,7 @@ ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene,
}
// ------------------------------------------------------------------------------------------------
void CallbackToLogRedirector (const char* msg, char* dt)
{
void CallbackToLogRedirector(const char *msg, char *dt) {
ai_assert(NULL != msg);
ai_assert(NULL != dt);
LogStream *s = (LogStream *)dt;
@ -353,8 +344,7 @@ void CallbackToLogRedirector (const char* msg, char* dt)
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const char* file)
{
ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) {
aiLogStream sout;
ASSIMP_BEGIN_EXCEPTION_REGION();
@ -362,8 +352,7 @@ ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const
if (!stream) {
sout.callback = NULL;
sout.user = NULL;
}
else {
} else {
sout.callback = &CallbackToLogRedirector;
sout.user = (char *)stream;
}
@ -373,8 +362,7 @@ ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiAttachLogStream( const aiLogStream* stream )
{
ASSIMP_API void aiAttachLogStream(const aiLogStream *stream) {
ASSIMP_BEGIN_EXCEPTION_REGION();
#ifndef ASSIMP_BUILD_SINGLETHREADED
@ -392,8 +380,7 @@ ASSIMP_API void aiAttachLogStream( const aiLogStream* stream )
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream)
{
ASSIMP_API aiReturn aiDetachLogStream(const aiLogStream *stream) {
ASSIMP_BEGIN_EXCEPTION_REGION();
#ifndef ASSIMP_BUILD_SINGLETHREADED
@ -418,8 +405,7 @@ ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream)
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiDetachAllLogStreams(void)
{
ASSIMP_API void aiDetachAllLogStreams(void) {
ASSIMP_BEGIN_EXCEPTION_REGION();
#ifndef ASSIMP_BUILD_SINGLETHREADED
std::lock_guard<std::mutex> lock(gLogStreamMutex);
@ -440,8 +426,7 @@ ASSIMP_API void aiDetachAllLogStreams(void)
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiEnableVerboseLogging(aiBool d)
{
ASSIMP_API void aiEnableVerboseLogging(aiBool d) {
if (!DefaultLogger::isNullLogger()) {
DefaultLogger::get()->setLogSeverity((d == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL));
}
@ -450,29 +435,25 @@ ASSIMP_API void aiEnableVerboseLogging(aiBool d)
// ------------------------------------------------------------------------------------------------
// Returns the error text of the last failed import process.
const char* aiGetErrorString()
{
const char *aiGetErrorString() {
return gLastErrorString.c_str();
}
// -----------------------------------------------------------------------------------------------
// Return the description of a importer given its index
const aiImporterDesc* aiGetImportFormatDescription( size_t pIndex)
{
const aiImporterDesc *aiGetImportFormatDescription(size_t pIndex) {
return Importer().GetImporterInfo(pIndex);
}
// -----------------------------------------------------------------------------------------------
// Return the number of importers
size_t aiGetImportFormatCount(void)
{
size_t aiGetImportFormatCount(void) {
return Importer().GetImporterCount();
}
// ------------------------------------------------------------------------------------------------
// Returns the error text of the last failed import process.
aiBool aiIsExtensionSupported(const char* szExtension)
{
aiBool aiIsExtensionSupported(const char *szExtension) {
ai_assert(NULL != szExtension);
aiBool candoit = AI_FALSE;
ASSIMP_BEGIN_EXCEPTION_REGION();
@ -487,8 +468,7 @@ aiBool aiIsExtensionSupported(const char* szExtension)
// ------------------------------------------------------------------------------------------------
// Get a list of all file extensions supported by ASSIMP
void aiGetExtensionList(aiString* szOut)
{
void aiGetExtensionList(aiString *szOut) {
ai_assert(NULL != szOut);
ASSIMP_BEGIN_EXCEPTION_REGION();
@ -502,8 +482,7 @@ void aiGetExtensionList(aiString* szOut)
// ------------------------------------------------------------------------------------------------
// Get the memory requirements for a particular import.
void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn,
C_STRUCT aiMemoryInfo* in)
{
C_STRUCT aiMemoryInfo *in) {
ASSIMP_BEGIN_EXCEPTION_REGION();
// find the importer associated with this data
@ -518,21 +497,18 @@ void aiGetMemoryRequirements(const C_STRUCT aiScene* pIn,
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API aiPropertyStore* aiCreatePropertyStore(void)
{
ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) {
return reinterpret_cast<aiPropertyStore *>(new PropertyMap());
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiReleasePropertyStore(aiPropertyStore* p)
{
ASSIMP_API void aiReleasePropertyStore(aiPropertyStore *p) {
delete reinterpret_cast<PropertyMap *>(p);
}
// ------------------------------------------------------------------------------------------------
// Importer::SetPropertyInteger
ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szName, int value)
{
ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore *p, const char *szName, int value) {
ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
SetGenericProperty<int>(pp->ints, szName, value);
@ -541,8 +517,7 @@ ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szNam
// ------------------------------------------------------------------------------------------------
// Importer::SetPropertyFloat
ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName, ai_real value)
{
ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore *p, const char *szName, ai_real value) {
ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
SetGenericProperty<ai_real>(pp->floats, szName, value);
@ -552,8 +527,7 @@ ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName,
// ------------------------------------------------------------------------------------------------
// Importer::SetPropertyString
ASSIMP_API void aiSetImportPropertyString(aiPropertyStore *p, const char *szName,
const C_STRUCT aiString* st)
{
const C_STRUCT aiString *st) {
if (!st) {
return;
}
@ -566,8 +540,7 @@ ASSIMP_API void aiSetImportPropertyString(aiPropertyStore* p, const char* szName
// ------------------------------------------------------------------------------------------------
// Importer::SetPropertyMatrix
ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore *p, const char *szName,
const C_STRUCT aiMatrix4x4* mat)
{
const C_STRUCT aiMatrix4x4 *mat) {
if (!mat) {
return;
}
@ -579,8 +552,7 @@ ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore* p, const char* szName
// ------------------------------------------------------------------------------------------------
// Rotation matrix to quaternion
ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion* quat,const aiMatrix3x3* mat)
{
ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion *quat, const aiMatrix3x3 *mat) {
ai_assert(NULL != quat);
ai_assert(NULL != mat);
*quat = aiQuaternion(*mat);
@ -590,8 +562,7 @@ ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion* quat,const aiMatrix3x
// Matrix decomposition
ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4 *mat, aiVector3D *scaling,
aiQuaternion *rotation,
aiVector3D* position)
{
aiVector3D *position) {
ai_assert(NULL != rotation);
ai_assert(NULL != position);
ai_assert(NULL != scaling);
@ -601,15 +572,13 @@ ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4* mat,aiVector3D* scaling,
// ------------------------------------------------------------------------------------------------
// Matrix transpose
ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3* mat)
{
ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3 *mat) {
ai_assert(NULL != mat);
mat->Transpose();
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4* mat)
{
ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4 *mat) {
ai_assert(NULL != mat);
mat->Transpose();
}
@ -617,8 +586,7 @@ ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4* mat)
// ------------------------------------------------------------------------------------------------
// Vector transformation
ASSIMP_API void aiTransformVecByMatrix3(aiVector3D *vec,
const aiMatrix3x3* mat)
{
const aiMatrix3x3 *mat) {
ai_assert(NULL != mat);
ai_assert(NULL != vec);
*vec *= (*mat);
@ -626,8 +594,7 @@ ASSIMP_API void aiTransformVecByMatrix3(aiVector3D* vec,
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiTransformVecByMatrix4(aiVector3D *vec,
const aiMatrix4x4* mat)
{
const aiMatrix4x4 *mat) {
ai_assert(NULL != mat);
ai_assert(NULL != vec);
@ -638,8 +605,7 @@ ASSIMP_API void aiTransformVecByMatrix4(aiVector3D* vec,
// Matrix multiplication
ASSIMP_API void aiMultiplyMatrix4(
aiMatrix4x4 *dst,
const aiMatrix4x4* src)
{
const aiMatrix4x4 *src) {
ai_assert(NULL != dst);
ai_assert(NULL != src);
*dst = (*dst) * (*src);
@ -648,8 +614,7 @@ ASSIMP_API void aiMultiplyMatrix4(
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiMultiplyMatrix3(
aiMatrix3x3 *dst,
const aiMatrix3x3* src)
{
const aiMatrix3x3 *src) {
ai_assert(NULL != dst);
ai_assert(NULL != src);
*dst = (*dst) * (*src);
@ -658,16 +623,14 @@ ASSIMP_API void aiMultiplyMatrix3(
// ------------------------------------------------------------------------------------------------
// Matrix identity
ASSIMP_API void aiIdentityMatrix3(
aiMatrix3x3* mat)
{
aiMatrix3x3 *mat) {
ai_assert(NULL != mat);
*mat = aiMatrix3x3();
}
// ------------------------------------------------------------------------------------------------
ASSIMP_API void aiIdentityMatrix4(
aiMatrix4x4* mat)
{
aiMatrix4x4 *mat) {
ai_assert(NULL != mat);
*mat = aiMatrix4x4();
}

42
code/FBX/FBXImportSettings.h
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,
@ -50,27 +49,25 @@ namespace Assimp {
namespace FBX {
/** FBX import settings, parts of which are publicly accessible via their corresponding AI_CONFIG constants */
struct ImportSettings
{
ImportSettings()
: strictMode(true)
, readAllLayers(true)
, readAllMaterials(false)
, readMaterials(true)
, readTextures(true)
, readCameras(true)
, readLights(true)
, readAnimations(true)
, readWeights(true)
, preservePivots(true)
, optimizeEmptyAnimationCurves(true)
, useLegacyEmbeddedTextureNaming(false)
, removeEmptyBones( true )
, convertToMeters( false ) {
struct ImportSettings {
ImportSettings() :
strictMode(true),
readAllLayers(true),
readAllMaterials(false),
readMaterials(true),
readTextures(true),
readCameras(true),
readLights(true),
readAnimations(true),
readWeights(true),
preservePivots(true),
optimizeEmptyAnimationCurves(true),
useLegacyEmbeddedTextureNaming(false),
removeEmptyBones(true),
convertToMeters(false) {
// empty
}
/** enable strict mode:
* - only accept fbx 2012, 2013 files
* - on the slightest error, give up.
@ -94,7 +91,6 @@ struct ImportSettings
* This bit is ignored unless readMaterials=true*/
bool readAllMaterials;
/** import materials (true) or skip them and assign a default
* material. The default value is true.*/
bool readMaterials;
@ -156,9 +152,7 @@ struct ImportSettings
bool convertToMeters;
};
} // !FBX
} // !Assimp
} // namespace FBX
} // namespace Assimp
#endif

1
code/FBX/FBXImporter.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,

27
code/FBX/FBXImporter.h
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,
@ -55,18 +54,20 @@ namespace Assimp {
// TinyFormatter.h
namespace Formatter {
template <typename T,typename TR, typename A> class basic_formatter;
template <typename T, typename TR, typename A>
class basic_formatter;
typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
}
} // namespace Formatter
// -------------------------------------------------------------------------------------------
/** Load the Autodesk FBX file format.
See http://en.wikipedia.org/wiki/FBX
*/
/// Loads the Autodesk FBX file format.
///
/// See http://en.wikipedia.org/wiki/FBX
// -------------------------------------------------------------------------------------------
class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter>
{
class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter> {
public:
FBXImporter();
virtual ~FBXImporter();
@ -74,11 +75,9 @@ public:
// --------------------
bool CanRead(const std::string &pFile,
IOSystem *pIOHandler,
bool checkSig
) const;
bool checkSig) const;
protected:
// --------------------
const aiImporterDesc *GetInfo() const;
@ -88,8 +87,7 @@ protected:
// --------------------
void InternReadFile(const std::string &pFile,
aiScene *pScene,
IOSystem* pIOHandler
);
IOSystem *pIOHandler);
private:
FBX::ImportSettings settings;
@ -97,4 +95,3 @@ private:
} // end of namespace Assimp
#endif // !INCLUDED_AI_FBX_IMPORTER_H

110
include/assimp/metadata.h
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,
@ -100,13 +98,27 @@ struct aiMetadataEntry {
*/
// -------------------------------------------------------------------------------
inline aiMetadataType GetAiType( bool ) { return AI_BOOL; }
inline aiMetadataType GetAiType( int32_t ) { return AI_INT32; }
inline aiMetadataType GetAiType( uint64_t ) { return AI_UINT64; }
inline aiMetadataType GetAiType( float ) { return AI_FLOAT; }
inline aiMetadataType GetAiType( double ) { return AI_DOUBLE; }
inline aiMetadataType GetAiType( const aiString & ) { return AI_AISTRING; }
inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; }
inline aiMetadataType GetAiType(bool) {
return AI_BOOL;
}
inline aiMetadataType GetAiType(int32_t) {
return AI_INT32;
}
inline aiMetadataType GetAiType(uint64_t) {
return AI_UINT64;
}
inline aiMetadataType GetAiType(float) {
return AI_FLOAT;
}
inline aiMetadataType GetAiType(double) {
return AI_DOUBLE;
}
inline aiMetadataType GetAiType(const aiString &) {
return AI_AISTRING;
}
inline aiMetadataType GetAiType(const aiVector3D &) {
return AI_AIVECTOR3D;
}
#endif // __cplusplus
@ -134,16 +146,14 @@ struct aiMetadata {
* @brief The default constructor, set all members to zero by default.
*/
aiMetadata() AI_NO_EXCEPT
: mNumProperties(0)
, mKeys(nullptr)
, mValues(nullptr) {
: mNumProperties(0),
mKeys(nullptr),
mValues(nullptr) {
// empty
}
aiMetadata( const aiMetadata &rhs )
: mNumProperties( rhs.mNumProperties )
, mKeys( nullptr )
, mValues( nullptr ) {
aiMetadata(const aiMetadata &rhs) :
mNumProperties(rhs.mNumProperties), mKeys(nullptr), mValues(nullptr) {
mKeys = new aiString[mNumProperties];
for (size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i) {
mKeys[i] = rhs.mKeys[i];
@ -160,45 +170,38 @@ struct aiMetadata {
int32_t v;
::memcpy(&v, rhs.mValues[i].mData, sizeof(int32_t));
mValues[i].mData = new int32_t(v);
}
break;
} break;
case AI_UINT64: {
uint64_t v;
::memcpy(&v, rhs.mValues[i].mData, sizeof(uint64_t));
mValues[i].mData = new uint64_t(v);
}
break;
} break;
case AI_FLOAT: {
float v;
::memcpy(&v, rhs.mValues[i].mData, sizeof(float));
mValues[i].mData = new float(v);
}
break;
} break;
case AI_DOUBLE: {
double v;
::memcpy(&v, rhs.mValues[i].mData, sizeof(double));
mValues[i].mData = new double(v);
}
break;
} break;
case AI_AISTRING: {
aiString v;
rhs.Get<aiString>(mKeys[i], v);
mValues[i].mData = new aiString(v);
}
break;
} break;
case AI_AIVECTOR3D: {
aiVector3D v;
rhs.Get<aiVector3D>(mKeys[i], v);
mValues[i].mData = new aiVector3D(v);
}
break;
} break;
#ifndef SWIG
case FORCE_32BIT:
#endif
default:
break;
}
}
}
@ -252,8 +255,7 @@ struct aiMetadata {
* @brief Allocates property fields + keys.
* @param numProperties Number of requested properties.
*/
static inline
aiMetadata *Alloc( unsigned int numProperties ) {
static inline aiMetadata *Alloc(unsigned int numProperties) {
if (0 == numProperties) {
return nullptr;
}
@ -269,19 +271,16 @@ struct aiMetadata {
/**
* @brief Deallocates property fields + keys.
*/
static inline
void Dealloc( aiMetadata *metadata ) {
static inline void Dealloc(aiMetadata *metadata) {
delete metadata;
}
template <typename T>
inline
void Add(const std::string& key, const T& value) {
inline void Add(const std::string &key, const T &value) {
aiString *new_keys = new aiString[mNumProperties + 1];
aiMetadataEntry *new_values = new aiMetadataEntry[mNumProperties + 1];
for(unsigned int i = 0; i < mNumProperties; ++i)
{
for (unsigned int i = 0; i < mNumProperties; ++i) {
new_keys[i] = mKeys[i];
new_values[i] = mValues[i];
}
@ -298,8 +297,7 @@ struct aiMetadata {
}
template <typename T>
inline
bool Set( unsigned index, const std::string& key, const T& value ) {
inline bool Set(unsigned index, const std::string &key, const T &value) {
// In range assertion
if (index >= mNumProperties) {
return false;
@ -322,8 +320,25 @@ struct aiMetadata {
}
template <typename T>
inline
bool Get( unsigned index, T& value ) const {
inline bool Set( const std::string &key, const T &value ) {
if (key.empty()) {
return false;
}
bool result = false;
for (unsigned int i = 0; i < mNumProperties; ++i) {
if (key == mKeys[i].C_Str()) {
Set(i, key, value);
result = true;
break;
}
}
return result;
}
template <typename T>
inline bool Get(unsigned index, T &value) const {
// In range assertion
if (index >= mNumProperties) {
return false;
@ -343,8 +358,7 @@ struct aiMetadata {
}
template <typename T>
inline
bool Get( const aiString& key, T& value ) const {
inline bool Get(const aiString &key, T &value) const {
// Search for the given key
for (unsigned int i = 0; i < mNumProperties; ++i) {
if (mKeys[i] == key) {
@ -355,8 +369,7 @@ struct aiMetadata {
}
template <typename T>
inline
bool Get( const std::string& key, T& value ) const {
inline bool Get(const std::string &key, T &value) const {
return Get(aiString(key), value);
}
@ -365,8 +378,7 @@ struct aiMetadata {
/// \param [out] pKey - pointer to the key value.
/// \param [out] pEntry - pointer to the entry: type and value.
/// \return false - if pIndex is out of range, else - true.
inline
bool Get(size_t index, const aiString*& key, const aiMetadataEntry*& entry) const {
inline bool Get(size_t index, const aiString *&key, const aiMetadataEntry *&entry) const {
if (index >= mNumProperties) {
return false;
}
@ -379,8 +391,7 @@ struct aiMetadata {
/// Check whether there is a metadata entry for the given key.
/// \param [in] Key - the key value value to check for.
inline
bool HasKey(const char* key) {
inline bool HasKey(const char *key) {
if (nullptr == key) {
return false;
}
@ -395,7 +406,6 @@ struct aiMetadata {
}
#endif // __cplusplus
};
#endif // AI_METADATA_H_INC

48
samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h
View File

@ -31,40 +31,40 @@ struct Texture {
class Mesh {
public:
std::vector<VERTEX> vertices;
std::vector<UINT> indices;
std::vector<Texture> textures;
ID3D11Device *dev;
std::vector<VERTEX> vertices_;
std::vector<UINT> indices_;
std::vector<Texture> textures_;
ID3D11Device *dev_;
Mesh(ID3D11Device *dev, const std::vector<VERTEX>& vertices, const std::vector<UINT>& indices, const std::vector<Texture>& textures) :
vertices(vertices),
indices(indices),
textures(textures),
dev(dev),
VertexBuffer(nullptr),
IndexBuffer(nullptr) {
this->setupMesh(this->dev);
vertices_(vertices),
indices_(indices),
textures_(textures),
dev_(dev),
VertexBuffer_(nullptr),
IndexBuffer_(nullptr) {
this->setupMesh(this->dev_);
}
void Draw(ID3D11DeviceContext *devcon) {
UINT stride = sizeof(VERTEX);
UINT offset = 0;
devcon->IASetVertexBuffers(0, 1, &VertexBuffer, &stride, &offset);
devcon->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0);
devcon->IASetVertexBuffers(0, 1, &VertexBuffer_, &stride, &offset);
devcon->IASetIndexBuffer(IndexBuffer_, DXGI_FORMAT_R32_UINT, 0);
devcon->PSSetShaderResources(0, 1, &textures[0].texture);
devcon->PSSetShaderResources(0, 1, &textures_[0].texture);
devcon->DrawIndexed(static_cast<UINT>(indices.size()), 0, 0);
devcon->DrawIndexed(static_cast<UINT>(indices_.size()), 0, 0);
}
void Close() {
SafeRelease(VertexBuffer);
SafeRelease(IndexBuffer);
SafeRelease(VertexBuffer_);
SafeRelease(IndexBuffer_);
}
private:
// Render data
ID3D11Buffer *VertexBuffer, *IndexBuffer;
ID3D11Buffer *VertexBuffer_, *IndexBuffer_;
// Functions
// Initializes all the buffer objects/arrays
@ -73,15 +73,15 @@ private:
D3D11_BUFFER_DESC vbd;
vbd.Usage = D3D11_USAGE_IMMUTABLE;
vbd.ByteWidth = static_cast<UINT>(sizeof(VERTEX) * vertices.size());
vbd.ByteWidth = static_cast<UINT>(sizeof(VERTEX) * vertices_.size());
vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbd.CPUAccessFlags = 0;
vbd.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = &vertices[0];
initData.pSysMem = &vertices_[0];
hr = dev->CreateBuffer(&vbd, &initData, &VertexBuffer);
hr = dev->CreateBuffer(&vbd, &initData, &VertexBuffer_);
if (FAILED(hr)) {
Close();
throw std::runtime_error("Failed to create vertex buffer.");
@ -89,14 +89,14 @@ private:
D3D11_BUFFER_DESC ibd;
ibd.Usage = D3D11_USAGE_IMMUTABLE;
ibd.ByteWidth = static_cast<UINT>(sizeof(UINT) * indices.size());
ibd.ByteWidth = static_cast<UINT>(sizeof(UINT) * indices_.size());
ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
ibd.CPUAccessFlags = 0;
ibd.MiscFlags = 0;
initData.pSysMem = &indices[0];
initData.pSysMem = &indices_[0];
hr = dev->CreateBuffer(&ibd, &initData, &IndexBuffer);
hr = dev->CreateBuffer(&ibd, &initData, &IndexBuffer_);
if (FAILED(hr)) {
Close();
throw std::runtime_error("Failed to create index buffer.");

52
samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp
View File

@ -1,12 +1,12 @@
#include "ModelLoader.h"
ModelLoader::ModelLoader() :
dev(nullptr),
devcon(nullptr),
meshes(),
directory(),
textures_loaded(),
hwnd(nullptr) {
dev_(nullptr),
devcon_(nullptr),
meshes_(),
directory_(),
textures_loaded_(),
hwnd_(nullptr) {
// empty
}
@ -25,11 +25,11 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
if (pScene == NULL)
return false;
this->directory = filename.substr(0, filename.find_last_of("/\\"));
this->directory_ = filename.substr(0, filename.find_last_of("/\\"));
this->dev = dev;
this->devcon = devcon;
this->hwnd = hwnd;
this->dev_ = dev;
this->devcon_ = devcon;
this->hwnd_ = hwnd;
processNode(pScene->mRootNode, pScene);
@ -37,8 +37,8 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
}
void ModelLoader::Draw(ID3D11DeviceContext * devcon) {
for (int i = 0; i < meshes.size(); ++i ) {
meshes[i].Draw(devcon);
for (size_t i = 0; i < meshes_.size(); ++i ) {
meshes_[i].Draw(devcon);
}
}
@ -88,7 +88,7 @@ Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene) {
textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
}
return Mesh(dev, vertices, indices, textures);
return Mesh(dev_, vertices, indices, textures);
}
std::vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, std::string typeName, const aiScene * scene) {
@ -98,9 +98,9 @@ std::vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextu
mat->GetTexture(type, i, &str);
// Check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
bool skip = false;
for (UINT j = 0; j < textures_loaded.size(); j++) {
if (std::strcmp(textures_loaded[j].path.c_str(), str.C_Str()) == 0) {
textures.push_back(textures_loaded[j]);
for (UINT j = 0; j < textures_loaded_.size(); j++) {
if (std::strcmp(textures_loaded_[j].path.c_str(), str.C_Str()) == 0) {
textures.push_back(textures_loaded_[j]);
skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization)
break;
}
@ -113,34 +113,34 @@ std::vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextu
texture.texture = getTextureFromModel(scene, textureindex);
} else {
std::string filename = std::string(str.C_Str());
filename = directory + '/' + filename;
filename = directory_ + '/' + filename;
std::wstring filenamews = std::wstring(filename.begin(), filename.end());
hr = CreateWICTextureFromFile(dev, devcon, filenamews.c_str(), nullptr, &texture.texture);
hr = CreateWICTextureFromFile(dev_, devcon_, filenamews.c_str(), nullptr, &texture.texture);
if (FAILED(hr))
MessageBox(hwnd, "Texture couldn't be loaded", "Error!", MB_ICONERROR | MB_OK);
MessageBox(hwnd_, "Texture couldn't be loaded", "Error!", MB_ICONERROR | MB_OK);
}
texture.type = typeName;
texture.path = str.C_Str();
textures.push_back(texture);
this->textures_loaded.push_back(texture); // Store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures.
this->textures_loaded_.push_back(texture); // Store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures.
}
}
return textures;
}
void ModelLoader::Close() {
for (auto& t : textures_loaded)
for (auto& t : textures_loaded_)
t.Release();
for (int i = 0; i < meshes.size(); i++) {
meshes[i].Close();
for (size_t i = 0; i < meshes_.size(); i++) {
meshes_[i].Close();
}
}
void ModelLoader::processNode(aiNode * node, const aiScene * scene) {
for (UINT i = 0; i < node->mNumMeshes; i++) {
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
meshes.push_back(this->processMesh(mesh, scene));
meshes_.push_back(this->processMesh(mesh, scene));
}
for (UINT i = 0; i < node->mNumChildren; i++) {
@ -179,9 +179,9 @@ ID3D11ShaderResourceView * ModelLoader::getTextureFromModel(const aiScene * scen
int* size = reinterpret_cast<int*>(&scene->mTextures[textureindex]->mWidth);
hr = CreateWICTextureFromMemory(dev, devcon, reinterpret_cast<unsigned char*>(scene->mTextures[textureindex]->pcData), *size, nullptr, &texture);
hr = CreateWICTextureFromMemory(dev_, devcon_, reinterpret_cast<unsigned char*>(scene->mTextures[textureindex]->pcData), *size, nullptr, &texture);
if (FAILED(hr))
MessageBox(hwnd, "Texture couldn't be created from memory!", "Error!", MB_ICONERROR | MB_OK);
MessageBox(hwnd_, "Texture couldn't be created from memory!", "Error!", MB_ICONERROR | MB_OK);
return texture;
}

12
samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h
View File

@ -25,12 +25,12 @@ public:
void Close();
private:
ID3D11Device *dev;
ID3D11DeviceContext *devcon;
std::vector<Mesh> meshes;
std::string directory;
std::vector<Texture> textures_loaded;
HWND hwnd;
ID3D11Device *dev_;
ID3D11DeviceContext *devcon_;
std::vector<Mesh> meshes_;
std::string directory_;
std::vector<Texture> textures_loaded_;
HWND hwnd_;
void processNode(aiNode* node, const aiScene* scene);
Mesh processMesh(aiMesh* mesh, const aiScene* scene);

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

@ -56,7 +56,7 @@ const char g_szClassName[] = "directxWindowClass";
static std::string g_ModelPath;
UINT width, height;
HWND hwnd = nullptr;
HWND g_hwnd = nullptr;
// ------------------------------------------------------------
// DirectX Variables
@ -120,8 +120,8 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
return 0;
}
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPWSTR lpCmdLine, int nCmdShow)
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
LPWSTR /*lpCmdLine*/, int nCmdShow)
{
int argc;
LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
@ -182,7 +182,7 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
RECT wr = { 0,0, SCREEN_WIDTH, SCREEN_HEIGHT };
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
hwnd = CreateWindowEx(
g_hwnd = CreateWindowEx(
WS_EX_CLIENTEDGE,
g_szClassName,
" Simple Textured Directx11 Sample ",
@ -191,21 +191,21 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
NULL, NULL, hInstance, NULL
);
if (hwnd == NULL)
if (g_hwnd == NULL)
{
MessageBox(NULL, "Window Creation Failed!", "Error!",
MB_ICONEXCLAMATION | MB_OK);
return 0;
}
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
ShowWindow(g_hwnd, nCmdShow);
UpdateWindow(g_hwnd);
width = wr.right - wr.left;
height = wr.bottom - wr.top;
try {
InitD3D(hInstance, hwnd);
InitD3D(hInstance, g_hwnd);
while (true)
{
@ -225,17 +225,17 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
CleanD3D();
return static_cast<int>(msg.wParam);
} catch (const std::exception& e) {
MessageBox(hwnd, e.what(), TEXT("Error!"), MB_ICONERROR | MB_OK);
MessageBox(g_hwnd, e.what(), TEXT("Error!"), MB_ICONERROR | MB_OK);
CleanD3D();
return EXIT_FAILURE;
} catch (...) {
MessageBox(hwnd, TEXT("Caught an unknown exception."), TEXT("Error!"), MB_ICONERROR | MB_OK);
MessageBox(g_hwnd, TEXT("Caught an unknown exception."), TEXT("Error!"), MB_ICONERROR | MB_OK);
CleanD3D();
return EXIT_FAILURE;
}
}
void InitD3D(HINSTANCE hinstance, HWND hWnd)
void InitD3D(HINSTANCE /*hinstance*/, HWND hWnd)
{
HRESULT hr;
@ -362,7 +362,7 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
}
// Note this tutorial doesn't handle full-screen swapchains so we block the ALT+ENTER shortcut
dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER);
dxgiFactory->MakeWindowAssociation(g_hwnd, DXGI_MWA_NO_ALT_ENTER);
dxgiFactory->Release();
@ -564,7 +564,7 @@ void InitGraphics()
m_View = XMMatrixLookAtLH(Eye, At, Up);
ourModel = new ModelLoader;
if (!ourModel->Load(hwnd, dev, devcon, g_ModelPath))
if (!ourModel->Load(g_hwnd, dev, devcon, g_ModelPath))
Throwanerror("Model couldn't be loaded");
}

4
test/unit/utFBXImporterExporter.cpp
View File

@ -213,6 +213,10 @@ TEST_F(utFBXImporterExporter, importUnitScaleFactor) {
double factor(0.0);
scene->mMetaData->Get("UnitScaleFactor", factor);
EXPECT_DOUBLE_EQ(500.0, factor);
scene->mMetaData->Set("UnitScaleFactor", factor * 2);
scene->mMetaData->Get("UnitScaleFactor", factor);
EXPECT_DOUBLE_EQ(1000.0, factor);
}
TEST_F(utFBXImporterExporter, importEmbeddedAsciiTest) {