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

693
code/Common/Assimp.cpp
View File

File diff suppressed because it is too large Load Diff

42
code/FBX/FBXImportSettings.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -50,27 +49,25 @@ namespace Assimp {
namespace FBX { namespace FBX {
/** FBX import settings, parts of which are publicly accessible via their corresponding AI_CONFIG constants */ /** FBX import settings, parts of which are publicly accessible via their corresponding AI_CONFIG constants */
struct ImportSettings struct ImportSettings {
{ ImportSettings() :
ImportSettings() strictMode(true),
: strictMode(true) readAllLayers(true),
, readAllLayers(true) readAllMaterials(false),
, readAllMaterials(false) readMaterials(true),
, readMaterials(true) readTextures(true),
, readTextures(true) readCameras(true),
, readCameras(true) readLights(true),
, readLights(true) readAnimations(true),
, readAnimations(true) readWeights(true),
, readWeights(true) preservePivots(true),
, preservePivots(true) optimizeEmptyAnimationCurves(true),
, optimizeEmptyAnimationCurves(true) useLegacyEmbeddedTextureNaming(false),
, useLegacyEmbeddedTextureNaming(false) removeEmptyBones(true),
, removeEmptyBones( true ) convertToMeters(false) {
, convertToMeters( false ) {
// empty // empty
} }
/** enable strict mode: /** enable strict mode:
* - only accept fbx 2012, 2013 files * - only accept fbx 2012, 2013 files
* - on the slightest error, give up. * - on the slightest error, give up.
@ -94,7 +91,6 @@ struct ImportSettings
* This bit is ignored unless readMaterials=true*/ * This bit is ignored unless readMaterials=true*/
bool readAllMaterials; bool readAllMaterials;
/** import materials (true) or skip them and assign a default /** import materials (true) or skip them and assign a default
* material. The default value is true.*/ * material. The default value is true.*/
bool readMaterials; bool readMaterials;
@ -156,9 +152,7 @@ struct ImportSettings
bool convertToMeters; bool convertToMeters;
}; };
} // namespace FBX
} // !FBX } // namespace Assimp
} // !Assimp
#endif #endif

1
code/FBX/FBXImporter.cpp
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,

45
code/FBX/FBXImporter.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -51,45 +50,44 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "FBXImportSettings.h" #include "FBXImportSettings.h"
namespace Assimp { namespace Assimp {
// TinyFormatter.h // TinyFormatter.h
namespace Formatter { namespace Formatter {
template <typename T,typename TR, typename A> class basic_formatter;
typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format; 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. /// Loads the Autodesk FBX file format.
///
See http://en.wikipedia.org/wiki/FBX /// See http://en.wikipedia.org/wiki/FBX
*/
// ------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------
class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter> class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter> {
{
public: public:
FBXImporter(); FBXImporter();
virtual ~FBXImporter(); virtual ~FBXImporter();
// -------------------- // --------------------
bool CanRead( const std::string& pFile, bool CanRead(const std::string &pFile,
IOSystem* pIOHandler, IOSystem *pIOHandler,
bool checkSig bool checkSig) const;
) const;
protected: protected:
// --------------------
const aiImporterDesc *GetInfo() const;
// -------------------- // --------------------
const aiImporterDesc* GetInfo () const; void SetupProperties(const Importer *pImp);
// -------------------- // --------------------
void SetupProperties(const Importer* pImp); void InternReadFile(const std::string &pFile,
aiScene *pScene,
// -------------------- IOSystem *pIOHandler);
void InternReadFile( const std::string& pFile,
aiScene* pScene,
IOSystem* pIOHandler
);
private: private:
FBX::ImportSettings settings; FBX::ImportSettings settings;
@ -97,4 +95,3 @@ private:
} // end of namespace Assimp } // end of namespace Assimp
#endif // !INCLUDED_AI_FBX_IMPORTER_H #endif // !INCLUDED_AI_FBX_IMPORTER_H

300
include/assimp/metadata.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -49,29 +47,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_METADATA_H_INC #define AI_METADATA_H_INC
#ifdef __GNUC__ #ifdef __GNUC__
# pragma GCC system_header #pragma GCC system_header
#endif #endif
#if defined(_MSC_VER) && (_MSC_VER <= 1500) #if defined(_MSC_VER) && (_MSC_VER <= 1500)
# include "Compiler/pstdint.h" #include "Compiler/pstdint.h"
#else #else
# include <stdint.h> #include <stdint.h>
#endif #endif
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
/** /**
* Enum used to distinguish data types * Enum used to distinguish data types
*/ */
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
typedef enum aiMetadataType { typedef enum aiMetadataType {
AI_BOOL = 0, AI_BOOL = 0,
AI_INT32 = 1, AI_INT32 = 1,
AI_UINT64 = 2, AI_UINT64 = 2,
AI_FLOAT = 3, AI_FLOAT = 3,
AI_DOUBLE = 4, AI_DOUBLE = 4,
AI_AISTRING = 5, AI_AISTRING = 5,
AI_AIVECTOR3D = 6, AI_AIVECTOR3D = 6,
AI_META_MAX = 7, AI_META_MAX = 7,
#ifndef SWIG #ifndef SWIG
FORCE_32BIT = INT_MAX FORCE_32BIT = INT_MAX
@ -84,10 +82,10 @@ typedef enum aiMetadataType {
* *
* The type field uniquely identifies the underlying type of the data field * The type field uniquely identifies the underlying type of the data field
*/ */
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiMetadataEntry { struct aiMetadataEntry {
aiMetadataType mType; aiMetadataType mType;
void* mData; void *mData;
}; };
#ifdef __cplusplus #ifdef __cplusplus
@ -98,15 +96,29 @@ struct aiMetadataEntry {
/** /**
* Helper functions to get the aiType enum entry for a type * Helper functions to get the aiType enum entry for a type
*/ */
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
inline aiMetadataType GetAiType( bool ) { return AI_BOOL; } inline aiMetadataType GetAiType(bool) {
inline aiMetadataType GetAiType( int32_t ) { return AI_INT32; } return AI_BOOL;
inline aiMetadataType GetAiType( uint64_t ) { return AI_UINT64; } }
inline aiMetadataType GetAiType( float ) { return AI_FLOAT; } inline aiMetadataType GetAiType(int32_t) {
inline aiMetadataType GetAiType( double ) { return AI_DOUBLE; } return AI_INT32;
inline aiMetadataType GetAiType( const aiString & ) { return AI_AISTRING; } }
inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; } 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 #endif // __cplusplus
@ -116,17 +128,17 @@ inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; }
* *
* Metadata is a key-value store using string keys and values. * Metadata is a key-value store using string keys and values.
*/ */
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiMetadata { struct aiMetadata {
/** Length of the mKeys and mValues arrays, respectively */ /** Length of the mKeys and mValues arrays, respectively */
unsigned int mNumProperties; unsigned int mNumProperties;
/** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */ /** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
C_STRUCT aiString* mKeys; C_STRUCT aiString *mKeys;
/** Arrays of values, may not be NULL. Entries in this array may be NULL if the /** Arrays of values, may not be NULL. Entries in this array may be NULL if the
* corresponding property key has no assigned value. */ * corresponding property key has no assigned value. */
C_STRUCT aiMetadataEntry* mValues; C_STRUCT aiMetadataEntry *mValues;
#ifdef __cplusplus #ifdef __cplusplus
@ -134,71 +146,62 @@ struct aiMetadata {
* @brief The default constructor, set all members to zero by default. * @brief The default constructor, set all members to zero by default.
*/ */
aiMetadata() AI_NO_EXCEPT aiMetadata() AI_NO_EXCEPT
: mNumProperties(0) : mNumProperties(0),
, mKeys(nullptr) mKeys(nullptr),
, mValues(nullptr) { mValues(nullptr) {
// empty // empty
} }
aiMetadata( const aiMetadata &rhs ) aiMetadata(const aiMetadata &rhs) :
: mNumProperties( rhs.mNumProperties ) mNumProperties(rhs.mNumProperties), mKeys(nullptr), mValues(nullptr) {
, mKeys( nullptr ) mKeys = new aiString[mNumProperties];
, mValues( nullptr ) { for (size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i) {
mKeys = new aiString[ mNumProperties ]; mKeys[i] = rhs.mKeys[i];
for ( size_t i = 0; i < static_cast<size_t>( mNumProperties ); ++i ) {
mKeys[ i ] = rhs.mKeys[ i ];
} }
mValues = new aiMetadataEntry[ mNumProperties ]; mValues = new aiMetadataEntry[mNumProperties];
for ( size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i ) { for (size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i) {
mValues[ i ].mType = rhs.mValues[ i ].mType; mValues[i].mType = rhs.mValues[i].mType;
switch ( rhs.mValues[ i ].mType ) { switch (rhs.mValues[i].mType) {
case AI_BOOL: case AI_BOOL:
mValues[ i ].mData = new bool; mValues[i].mData = new bool;
::memcpy( mValues[ i ].mData, rhs.mValues[ i ].mData, sizeof(bool) ); ::memcpy(mValues[i].mData, rhs.mValues[i].mData, sizeof(bool));
break; break;
case AI_INT32: { case AI_INT32: {
int32_t v; int32_t v;
::memcpy( &v, rhs.mValues[ i ].mData, sizeof( int32_t ) ); ::memcpy(&v, rhs.mValues[i].mData, sizeof(int32_t));
mValues[ i ].mData = new int32_t( v ); mValues[i].mData = new int32_t(v);
} } break;
break;
case AI_UINT64: { case AI_UINT64: {
uint64_t v; uint64_t v;
::memcpy( &v, rhs.mValues[ i ].mData, sizeof( uint64_t ) ); ::memcpy(&v, rhs.mValues[i].mData, sizeof(uint64_t));
mValues[ i ].mData = new uint64_t( v ); mValues[i].mData = new uint64_t(v);
} } break;
break;
case AI_FLOAT: { case AI_FLOAT: {
float v; float v;
::memcpy( &v, rhs.mValues[ i ].mData, sizeof( float ) ); ::memcpy(&v, rhs.mValues[i].mData, sizeof(float));
mValues[ i ].mData = new float( v ); mValues[i].mData = new float(v);
} } break;
break;
case AI_DOUBLE: { case AI_DOUBLE: {
double v; double v;
::memcpy( &v, rhs.mValues[ i ].mData, sizeof( double ) ); ::memcpy(&v, rhs.mValues[i].mData, sizeof(double));
mValues[ i ].mData = new double( v ); mValues[i].mData = new double(v);
} } break;
break;
case AI_AISTRING: { case AI_AISTRING: {
aiString v; aiString v;
rhs.Get<aiString>( mKeys[ i ], v ); rhs.Get<aiString>(mKeys[i], v);
mValues[ i ].mData = new aiString( v ); mValues[i].mData = new aiString(v);
} } break;
break;
case AI_AIVECTOR3D: { case AI_AIVECTOR3D: {
aiVector3D v; aiVector3D v;
rhs.Get<aiVector3D>( mKeys[ i ], v ); rhs.Get<aiVector3D>(mKeys[i], v);
mValues[ i ].mData = new aiVector3D( v ); mValues[i].mData = new aiVector3D(v);
} } break;
break;
#ifndef SWIG #ifndef SWIG
case FORCE_32BIT: case FORCE_32BIT:
#endif #endif
default: default:
break; break;
} }
} }
} }
@ -206,33 +209,33 @@ struct aiMetadata {
* @brief The destructor. * @brief The destructor.
*/ */
~aiMetadata() { ~aiMetadata() {
delete [] mKeys; delete[] mKeys;
mKeys = nullptr; mKeys = nullptr;
if (mValues) { if (mValues) {
// Delete each metadata entry // Delete each metadata entry
for (unsigned i=0; i<mNumProperties; ++i) { for (unsigned i = 0; i < mNumProperties; ++i) {
void* data = mValues[i].mData; void *data = mValues[i].mData;
switch (mValues[i].mType) { switch (mValues[i].mType) {
case AI_BOOL: case AI_BOOL:
delete static_cast< bool* >( data ); delete static_cast<bool *>(data);
break; break;
case AI_INT32: case AI_INT32:
delete static_cast< int32_t* >( data ); delete static_cast<int32_t *>(data);
break; break;
case AI_UINT64: case AI_UINT64:
delete static_cast< uint64_t* >( data ); delete static_cast<uint64_t *>(data);
break; break;
case AI_FLOAT: case AI_FLOAT:
delete static_cast< float* >( data ); delete static_cast<float *>(data);
break; break;
case AI_DOUBLE: case AI_DOUBLE:
delete static_cast< double* >( data ); delete static_cast<double *>(data);
break; break;
case AI_AISTRING: case AI_AISTRING:
delete static_cast< aiString* >( data ); delete static_cast<aiString *>(data);
break; break;
case AI_AIVECTOR3D: case AI_AIVECTOR3D:
delete static_cast< aiVector3D* >( data ); delete static_cast<aiVector3D *>(data);
break; break;
#ifndef SWIG #ifndef SWIG
case FORCE_32BIT: case FORCE_32BIT:
@ -243,7 +246,7 @@ struct aiMetadata {
} }
// Delete the metadata array // Delete the metadata array
delete [] mValues; delete[] mValues;
mValues = nullptr; mValues = nullptr;
} }
} }
@ -252,16 +255,15 @@ struct aiMetadata {
* @brief Allocates property fields + keys. * @brief Allocates property fields + keys.
* @param numProperties Number of requested properties. * @param numProperties Number of requested properties.
*/ */
static inline static inline aiMetadata *Alloc(unsigned int numProperties) {
aiMetadata *Alloc( unsigned int numProperties ) { if (0 == numProperties) {
if ( 0 == numProperties ) {
return nullptr; return nullptr;
} }
aiMetadata *data = new aiMetadata; aiMetadata *data = new aiMetadata;
data->mNumProperties = numProperties; data->mNumProperties = numProperties;
data->mKeys = new aiString[ data->mNumProperties ](); data->mKeys = new aiString[data->mNumProperties]();
data->mValues = new aiMetadataEntry[ data->mNumProperties ](); data->mValues = new aiMetadataEntry[data->mNumProperties]();
return data; return data;
} }
@ -269,44 +271,40 @@ struct aiMetadata {
/** /**
* @brief Deallocates property fields + keys. * @brief Deallocates property fields + keys.
*/ */
static inline static inline void Dealloc(aiMetadata *metadata) {
void Dealloc( aiMetadata *metadata ) {
delete metadata; delete metadata;
} }
template<typename T> template <typename T>
inline inline void Add(const std::string &key, const T &value) {
void Add(const std::string& key, const T& value) { aiString *new_keys = new aiString[mNumProperties + 1];
aiString* new_keys = new aiString[mNumProperties + 1]; aiMetadataEntry *new_values = new aiMetadataEntry[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_keys[i] = mKeys[i]; new_values[i] = mValues[i];
new_values[i] = mValues[i]; }
}
delete[] mKeys; delete[] mKeys;
delete[] mValues; delete[] mValues;
mKeys = new_keys; mKeys = new_keys;
mValues = new_values; mValues = new_values;
mNumProperties++; mNumProperties++;
Set(mNumProperties - 1, key, value); Set(mNumProperties - 1, key, value);
} }
template<typename T> template <typename T>
inline inline bool Set(unsigned index, const std::string &key, const T &value) {
bool Set( unsigned index, const std::string& key, const T& value ) {
// In range assertion // In range assertion
if ( index >= mNumProperties ) { if (index >= mNumProperties) {
return false; return false;
} }
// Ensure that we have a valid key. // Ensure that we have a valid key.
if ( key.empty() ) { if (key.empty()) {
return false; return false;
} }
@ -321,73 +319,86 @@ struct aiMetadata {
return true; return true;
} }
template<typename T> template <typename T>
inline inline bool Set( const std::string &key, const T &value ) {
bool Get( unsigned index, T& value ) const { 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 // In range assertion
if ( index >= mNumProperties ) { if (index >= mNumProperties) {
return false; return false;
} }
// Return false if the output data type does // Return false if the output data type does
// not match the found value's data type // not match the found value's data type
if ( GetAiType( value ) != mValues[ index ].mType ) { if (GetAiType(value) != mValues[index].mType) {
return false; return false;
} }
// Otherwise, output the found value and // Otherwise, output the found value and
// return true // return true
value = *static_cast<T*>(mValues[index].mData); value = *static_cast<T *>(mValues[index].mData);
return true; return true;
} }
template<typename T> template <typename T>
inline inline bool Get(const aiString &key, T &value) const {
bool Get( const aiString& key, T& value ) const {
// Search for the given key // Search for the given key
for ( unsigned int i = 0; i < mNumProperties; ++i ) { for (unsigned int i = 0; i < mNumProperties; ++i) {
if ( mKeys[ i ] == key ) { if (mKeys[i] == key) {
return Get( i, value ); return Get(i, value);
} }
} }
return false; return false;
} }
template<typename T> template <typename T>
inline inline bool Get(const std::string &key, T &value) const {
bool Get( const std::string& key, T& value ) const {
return Get(aiString(key), value); return Get(aiString(key), value);
} }
/// Return metadata entry for analyzing it by user. /// Return metadata entry for analyzing it by user.
/// \param [in] pIndex - index of the entry. /// \param [in] pIndex - index of the entry.
/// \param [out] pKey - pointer to the key value. /// \param [out] pKey - pointer to the key value.
/// \param [out] pEntry - pointer to the entry: type and value. /// \param [out] pEntry - pointer to the entry: type and value.
/// \return false - if pIndex is out of range, else - true. /// \return false - if pIndex is out of range, else - true.
inline inline bool Get(size_t index, const aiString *&key, const aiMetadataEntry *&entry) const {
bool Get(size_t index, const aiString*& key, const aiMetadataEntry*& entry) const { if (index >= mNumProperties) {
if ( index >= mNumProperties ) {
return false; return false;
} }
key = &mKeys[index]; key = &mKeys[index];
entry = &mValues[index]; entry = &mValues[index];
return true; return true;
} }
/// Check whether there is a metadata entry for the given key. /// Check whether there is a metadata entry for the given key.
/// \param [in] Key - the key value value to check for. /// \param [in] Key - the key value value to check for.
inline inline bool HasKey(const char *key) {
bool HasKey(const char* key) { if (nullptr == key) {
if ( nullptr == key ) {
return false; return false;
} }
// Search for the given key // Search for the given key
for (unsigned int i = 0; i < mNumProperties; ++i) { for (unsigned int i = 0; i < mNumProperties; ++i) {
if ( 0 == strncmp(mKeys[i].C_Str(), key, mKeys[i].length ) ) { if (0 == strncmp(mKeys[i].C_Str(), key, mKeys[i].length)) {
return true; return true;
} }
} }
@ -395,7 +406,6 @@ struct aiMetadata {
} }
#endif // __cplusplus #endif // __cplusplus
}; };
#endif // AI_METADATA_H_INC #endif // AI_METADATA_H_INC

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

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

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

@ -1,12 +1,12 @@
#include "ModelLoader.h" #include "ModelLoader.h"
ModelLoader::ModelLoader() : ModelLoader::ModelLoader() :
dev(nullptr), dev_(nullptr),
devcon(nullptr), devcon_(nullptr),
meshes(), meshes_(),
directory(), directory_(),
textures_loaded(), textures_loaded_(),
hwnd(nullptr) { hwnd_(nullptr) {
// empty // empty
} }
@ -25,11 +25,11 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
if (pScene == NULL) if (pScene == NULL)
return false; return false;
this->directory = filename.substr(0, filename.find_last_of("/\\")); this->directory_ = filename.substr(0, filename.find_last_of("/\\"));
this->dev = dev; this->dev_ = dev;
this->devcon = devcon; this->devcon_ = devcon;
this->hwnd = hwnd; this->hwnd_ = hwnd;
processNode(pScene->mRootNode, pScene); processNode(pScene->mRootNode, pScene);
@ -37,8 +37,8 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
} }
void ModelLoader::Draw(ID3D11DeviceContext * devcon) { void ModelLoader::Draw(ID3D11DeviceContext * devcon) {
for (int i = 0; i < meshes.size(); ++i ) { for (size_t i = 0; i < meshes_.size(); ++i ) {
meshes[i].Draw(devcon); meshes_[i].Draw(devcon);
} }
} }
@ -88,7 +88,7 @@ Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene) {
textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); 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) { 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); mat->GetTexture(type, i, &str);
// Check if texture was loaded before and if so, continue to next iteration: skip loading a new texture // Check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
bool skip = false; bool skip = false;
for (UINT j = 0; j < textures_loaded.size(); j++) { for (UINT j = 0; j < textures_loaded_.size(); j++) {
if (std::strcmp(textures_loaded[j].path.c_str(), str.C_Str()) == 0) { if (std::strcmp(textures_loaded_[j].path.c_str(), str.C_Str()) == 0) {
textures.push_back(textures_loaded[j]); textures.push_back(textures_loaded_[j]);
skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization) skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization)
break; break;
} }
@ -113,34 +113,34 @@ std::vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextu
texture.texture = getTextureFromModel(scene, textureindex); texture.texture = getTextureFromModel(scene, textureindex);
} else { } else {
std::string filename = std::string(str.C_Str()); std::string filename = std::string(str.C_Str());
filename = directory + '/' + filename; filename = directory_ + '/' + filename;
std::wstring filenamews = std::wstring(filename.begin(), filename.end()); 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)) 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.type = typeName;
texture.path = str.C_Str(); texture.path = str.C_Str();
textures.push_back(texture); 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; return textures;
} }
void ModelLoader::Close() { void ModelLoader::Close() {
for (auto& t : textures_loaded) for (auto& t : textures_loaded_)
t.Release(); t.Release();
for (int i = 0; i < meshes.size(); i++) { for (size_t i = 0; i < meshes_.size(); i++) {
meshes[i].Close(); meshes_[i].Close();
} }
} }
void ModelLoader::processNode(aiNode * node, const aiScene * scene) { void ModelLoader::processNode(aiNode * node, const aiScene * scene) {
for (UINT i = 0; i < node->mNumMeshes; i++) { for (UINT i = 0; i < node->mNumMeshes; i++) {
aiMesh* mesh = scene->mMeshes[node->mMeshes[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++) { 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); 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)) 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; return texture;
} }

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

@ -25,12 +25,12 @@ public:
void Close(); void Close();
private: private:
ID3D11Device *dev; ID3D11Device *dev_;
ID3D11DeviceContext *devcon; ID3D11DeviceContext *devcon_;
std::vector<Mesh> meshes; std::vector<Mesh> meshes_;
std::string directory; std::string directory_;
std::vector<Texture> textures_loaded; std::vector<Texture> textures_loaded_;
HWND hwnd; HWND hwnd_;
void processNode(aiNode* node, const aiScene* scene); void processNode(aiNode* node, const aiScene* scene);
Mesh processMesh(aiMesh* mesh, 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; static std::string g_ModelPath;
UINT width, height; UINT width, height;
HWND hwnd = nullptr; HWND g_hwnd = nullptr;
// ------------------------------------------------------------ // ------------------------------------------------------------
// DirectX Variables // DirectX Variables
@ -120,8 +120,8 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
return 0; return 0;
} }
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
LPWSTR lpCmdLine, int nCmdShow) LPWSTR /*lpCmdLine*/, int nCmdShow)
{ {
int argc; int argc;
LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &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 }; RECT wr = { 0,0, SCREEN_WIDTH, SCREEN_HEIGHT };
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE); AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
hwnd = CreateWindowEx( g_hwnd = CreateWindowEx(
WS_EX_CLIENTEDGE, WS_EX_CLIENTEDGE,
g_szClassName, g_szClassName,
" Simple Textured Directx11 Sample ", " Simple Textured Directx11 Sample ",
@ -191,21 +191,21 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
NULL, NULL, hInstance, NULL NULL, NULL, hInstance, NULL
); );
if (hwnd == NULL) if (g_hwnd == NULL)
{ {
MessageBox(NULL, "Window Creation Failed!", "Error!", MessageBox(NULL, "Window Creation Failed!", "Error!",
MB_ICONEXCLAMATION | MB_OK); MB_ICONEXCLAMATION | MB_OK);
return 0; return 0;
} }
ShowWindow(hwnd, nCmdShow); ShowWindow(g_hwnd, nCmdShow);
UpdateWindow(hwnd); UpdateWindow(g_hwnd);
width = wr.right - wr.left; width = wr.right - wr.left;
height = wr.bottom - wr.top; height = wr.bottom - wr.top;
try { try {
InitD3D(hInstance, hwnd); InitD3D(hInstance, g_hwnd);
while (true) while (true)
{ {
@ -225,17 +225,17 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
CleanD3D(); CleanD3D();
return static_cast<int>(msg.wParam); return static_cast<int>(msg.wParam);
} catch (const std::exception& e) { } 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(); CleanD3D();
return EXIT_FAILURE; return EXIT_FAILURE;
} catch (...) { } 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(); CleanD3D();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
} }
void InitD3D(HINSTANCE hinstance, HWND hWnd) void InitD3D(HINSTANCE /*hinstance*/, HWND hWnd)
{ {
HRESULT hr; 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 // 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(); dxgiFactory->Release();
@ -564,7 +564,7 @@ void InitGraphics()
m_View = XMMatrixLookAtLH(Eye, At, Up); m_View = XMMatrixLookAtLH(Eye, At, Up);
ourModel = new ModelLoader; 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"); 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); double factor(0.0);
scene->mMetaData->Get("UnitScaleFactor", factor); scene->mMetaData->Get("UnitScaleFactor", factor);
EXPECT_DOUBLE_EQ(500.0, 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) { TEST_F(utFBXImporterExporter, importEmbeddedAsciiTest) {