From 9b83d748305e23d52b7c7118ecd65fed76352453 Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Sat, 28 Mar 2020 09:48:55 +0100 Subject: [PATCH] apply code-conventions to unrealloader --- code/Unreal/UnrealLoader.cpp | 353 +++++++++++++++++------------------ code/Unreal/UnrealLoader.h | 19 +- 2 files changed, 178 insertions(+), 194 deletions(-) diff --git a/code/Unreal/UnrealLoader.cpp b/code/Unreal/UnrealLoader.cpp index 86563299c..275c39b32 100644 --- a/code/Unreal/UnrealLoader.cpp +++ b/code/Unreal/UnrealLoader.cpp @@ -51,23 +51,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "Unreal/UnrealLoader.h" #include "PostProcessing/ConvertToLHProcess.h" -#include #include +#include #include -#include +#include +#include #include #include -#include -#include +#include -#include #include +#include using namespace Assimp; namespace Unreal { - /* +/* 0 = Normal one-sided 1 = Normal two-sided 2 = Translucent two-sided @@ -76,78 +76,78 @@ namespace Unreal { 8 = Placeholder triangle for weapon positioning (invisible) */ enum MeshFlags { - MF_NORMAL_OS = 0, - MF_NORMAL_TS = 1, - MF_NORMAL_TRANS_TS = 2, - MF_NORMAL_MASKED_TS = 3, - MF_NORMAL_MOD_TS = 4, - MF_WEAPON_PLACEHOLDER = 8 + MF_NORMAL_OS = 0, + MF_NORMAL_TS = 1, + MF_NORMAL_TRANS_TS = 2, + MF_NORMAL_MASKED_TS = 3, + MF_NORMAL_MOD_TS = 4, + MF_WEAPON_PLACEHOLDER = 8 }; // a single triangle struct Triangle { - uint16_t mVertex[3]; // Vertex indices - char mType; // James' Mesh Type - char mColor; // Color for flat and Gourand Shaded - unsigned char mTex[3][2]; // Texture UV coordinates - unsigned char mTextureNum; // Source texture offset - char mFlags; // Unreal Mesh Flags (unused) - unsigned int matIndex; + uint16_t mVertex[3]; // Vertex indices + char mType; // James' Mesh Type + char mColor; // Color for flat and Gourand Shaded + unsigned char mTex[3][2]; // Texture UV coordinates + unsigned char mTextureNum; // Source texture offset + char mFlags; // Unreal Mesh Flags (unused) + unsigned int matIndex; }; // temporary representation for a material struct TempMat { - TempMat() : - type(), tex(), numFaces(0) {} + TempMat() : + type(MF_NORMAL_OS), tex(), numFaces(0) {} - explicit TempMat(const Triangle &in) : - type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {} + explicit TempMat(const Triangle &in) : + type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {} - // type of mesh - Unreal::MeshFlags type; + // type of mesh + Unreal::MeshFlags type; - // index of texture - unsigned int tex; + // index of texture + unsigned int tex; - // number of faces using us - unsigned int numFaces; + // number of faces using us + unsigned int numFaces; - // for std::find - bool operator==(const TempMat &o) { - return (tex == o.tex && type == o.type); - } + // for std::find + bool operator==(const TempMat &o) { + return (tex == o.tex && type == o.type); + } }; struct Vertex { - int32_t X : 11; - int32_t Y : 11; - int32_t Z : 10; + int32_t X : 11; + int32_t Y : 11; + int32_t Z : 10; }; // UNREAL vertex compression inline void CompressVertex(const aiVector3D &v, uint32_t &out) { - union { - Vertex n; - int32_t t; - }; + union { + Vertex n; + int32_t t; + }; t = 0; - n.X = (int32_t)v.x; - n.Y = (int32_t)v.y; - n.Z = (int32_t)v.z; - ::memcpy(&out, &t, sizeof(int32_t)); + n.X = (int32_t)v.x; + n.Y = (int32_t)v.y; + n.Z = (int32_t)v.z; + ::memcpy(&out, &t, sizeof(int32_t)); } // UNREAL vertex decompression inline void DecompressVertex(aiVector3D &v, int32_t in) { - union { - Vertex n; - int32_t i; - }; - i = in; + union { + Vertex n; + int32_t i; + }; + i = in; - v.x = (float)n.X; - v.y = (float)n.Y; - v.z = (float)n.Z; + v.x = (float)n.X; + v.y = (float)n.Y; + v.z = (float)n.Z; } } // end namespace Unreal @@ -165,79 +165,70 @@ static const aiImporterDesc desc = { "3d uc" }; - // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer -UnrealImporter::UnrealImporter() -: configFrameID (0) -, configHandleFlags (true) -{} +UnrealImporter::UnrealImporter() : + mConfigFrameID(0), mConfigHandleFlags(true) {} // ------------------------------------------------------------------------------------------------ // Destructor, private as well -UnrealImporter::~UnrealImporter() -{} +UnrealImporter::~UnrealImporter() {} // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. -bool UnrealImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const -{ - return SimpleExtensionCheck(pFile,"3d","uc"); +bool UnrealImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { + return SimpleExtensionCheck(pFile, "3d", "uc"); } // ------------------------------------------------------------------------------------------------ // Build a string of all file extensions supported -const aiImporterDesc* UnrealImporter::GetInfo () const -{ +const aiImporterDesc *UnrealImporter::GetInfo() const { return &desc; } // ------------------------------------------------------------------------------------------------ // Setup configuration properties for the loader -void UnrealImporter::SetupProperties(const Importer* pImp) -{ +void UnrealImporter::SetupProperties(const Importer *pImp) { // The // AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. - configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME,-1); - if(static_cast(-1) == configFrameID) { - configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0); + mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME, -1); + if (static_cast(-1) == mConfigFrameID) { + mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0); } // AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true - configHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS,1)); + mConfigHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, 1)); } // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. -void UnrealImporter::InternReadFile( const std::string& pFile, - aiScene* pScene, IOSystem* pIOHandler) -{ +void UnrealImporter::InternReadFile(const std::string &pFile, + aiScene *pScene, IOSystem *pIOHandler) { // For any of the 3 files being passed get the three correct paths // First of all, determine file extension std::string::size_type pos = pFile.find_last_of('.'); std::string extension = GetExtension(pFile); - std::string d_path,a_path,uc_path; - if (extension == "3d") { + std::string d_path, a_path, uc_path; + if (extension == "3d") { // jjjj_d.3d // jjjj_a.3d pos = pFile.find_last_of('_'); if (std::string::npos == pos) { throw DeadlyImportError("UNREAL: Unexpected naming scheme"); } - extension = pFile.substr(0,pos); - } - else { - extension = pFile.substr(0,pos); + extension = pFile.substr(0, pos); + } else { + extension = pFile.substr(0, pos); } // build proper paths - d_path = extension+"_d.3d"; - a_path = extension+"_a.3d"; - uc_path = extension+".uc"; + d_path = extension + "_d.3d"; + a_path = extension + "_a.3d"; + uc_path = extension + ".uc"; - ASSIMP_LOG_DEBUG_F( "UNREAL: data file is ", d_path); + ASSIMP_LOG_DEBUG_F("UNREAL: data file is ", d_path); ASSIMP_LOG_DEBUG_F("UNREAL: aniv file is ", a_path); ASSIMP_LOG_DEBUG_F("UNREAL: uc file is ", uc_path); @@ -258,11 +249,11 @@ void UnrealImporter::InternReadFile( const std::string& pFile, // collect triangles std::vector triangles(numTris); - for (auto & tri : triangles) { - for (unsigned int i = 0; i < 3;++i) { + for (auto &tri : triangles) { + for (unsigned int i = 0; i < 3; ++i) { tri.mVertex[i] = d_reader.GetI2(); - if (tri.mVertex[i] >= numTris) { + if (tri.mVertex[i] >= numTris) { ASSIMP_LOG_WARN("UNREAL: vertex index out of range"); tri.mVertex[i] = 0; } @@ -270,7 +261,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile, tri.mType = d_reader.GetI1(); // handle mesh flagss? - if (configHandleFlags) + if (mConfigHandleFlags) tri.mType = Unreal::MF_NORMAL_OS; else { // ignore MOD and MASKED for the moment, treat them as two-sided @@ -279,12 +270,12 @@ void UnrealImporter::InternReadFile( const std::string& pFile, } d_reader.IncPtr(1); - for (unsigned int i = 0; i < 3;++i) - for (unsigned int i2 = 0; i2 < 2;++i2) + for (unsigned int i = 0; i < 3; ++i) + for (unsigned int i2 = 0; i2 < 2; ++i2) tri.mTex[i][i2] = d_reader.GetI1(); tri.mTextureNum = d_reader.GetI1(); - maxTexIdx = std::max(maxTexIdx,(unsigned int)tri.mTextureNum); + maxTexIdx = std::max(maxTexIdx, (unsigned int)tri.mTextureNum); d_reader.IncPtr(1); } @@ -295,63 +286,64 @@ void UnrealImporter::InternReadFile( const std::string& pFile, // read number of frames const uint32_t numFrames = a_reader.GetI2(); - if (configFrameID >= numFrames) { + if (mConfigFrameID >= numFrames) { throw DeadlyImportError("UNREAL: The requested frame does not exist"); } uint32_t st = a_reader.GetI2(); - if (st != numVert*4u) + if (st != numVert * 4u) throw DeadlyImportError("UNREAL: Unexpected aniv file length"); // skip to our frame - a_reader.IncPtr(configFrameID *numVert*4); + a_reader.IncPtr(mConfigFrameID * numVert * 4); // collect vertices std::vector vertices(numVert); - for (auto &vertex : vertices) { + for (auto &vertex : vertices) { int32_t val = a_reader.GetI4(); - Unreal::DecompressVertex(vertex ,val); + Unreal::DecompressVertex(vertex, val); } // list of textures. - std::vector< std::pair > textures; + std::vector> textures; // allocate the output scene - aiNode* nd = pScene->mRootNode = new aiNode(); + aiNode *nd = pScene->mRootNode = new aiNode(); nd->mName.Set(""); // we can live without the uc file if necessary - std::unique_ptr pb (pIOHandler->Open(uc_path)); - if (pb.get()) { + std::unique_ptr pb(pIOHandler->Open(uc_path)); + if (pb.get()) { std::vector _data; - TextFileToBuffer(pb.get(),_data); - const char* data = &_data[0]; + TextFileToBuffer(pb.get(), _data); + const char *data = &_data[0]; - std::vector< std::pair< std::string,std::string > > tempTextures; + std::vector> tempTextures; // do a quick search in the UC file for some known, usually texture-related, tags - for (;*data;++data) { - if (TokenMatchI(data,"#exec",5)) { + for (; *data; ++data) { + if (TokenMatchI(data, "#exec", 5)) { SkipSpacesAndLineEnd(&data); // #exec TEXTURE IMPORT [...] NAME=jjjjj [...] FILE=jjjj.pcx [...] - if (TokenMatchI(data,"TEXTURE",7)) { + if (TokenMatchI(data, "TEXTURE", 7)) { SkipSpacesAndLineEnd(&data); - if (TokenMatchI(data,"IMPORT",6)) { - tempTextures.push_back(std::pair< std::string,std::string >()); - std::pair< std::string,std::string >& me = tempTextures.back(); - for (;!IsLineEnd(*data);++data) { - if (!::ASSIMP_strincmp(data,"NAME=",5)) { - const char *d = data+=5; - for (;!IsSpaceOrNewLine(*data);++data); - me.first = std::string(d,(size_t)(data-d)); - } - else if (!::ASSIMP_strincmp(data,"FILE=",5)) { - const char *d = data+=5; - for (;!IsSpaceOrNewLine(*data);++data); - me.second = std::string(d,(size_t)(data-d)); + if (TokenMatchI(data, "IMPORT", 6)) { + tempTextures.push_back(std::pair()); + std::pair &me = tempTextures.back(); + for (; !IsLineEnd(*data); ++data) { + if (!::ASSIMP_strincmp(data, "NAME=", 5)) { + const char *d = data += 5; + for (; !IsSpaceOrNewLine(*data); ++data) + ; + me.first = std::string(d, (size_t)(data - d)); + } else if (!::ASSIMP_strincmp(data, "FILE=", 5)) { + const char *d = data += 5; + for (; !IsSpaceOrNewLine(*data); ++data) + ; + me.second = std::string(d, (size_t)(data - d)); } } if (!me.first.length() || !me.second.length()) @@ -360,65 +352,61 @@ void UnrealImporter::InternReadFile( const std::string& pFile, } // #exec MESHMAP SETTEXTURE MESHMAP=box NUM=1 TEXTURE=Jtex1 // #exec MESHMAP SCALE MESHMAP=box X=0.1 Y=0.1 Z=0.2 - else if (TokenMatchI(data,"MESHMAP",7)) { + else if (TokenMatchI(data, "MESHMAP", 7)) { SkipSpacesAndLineEnd(&data); - if (TokenMatchI(data,"SETTEXTURE",10)) { + if (TokenMatchI(data, "SETTEXTURE", 10)) { textures.push_back(std::pair()); - std::pair& me = textures.back(); + std::pair &me = textures.back(); - for (;!IsLineEnd(*data);++data) { - if (!::ASSIMP_strincmp(data,"NUM=",4)) { + for (; !IsLineEnd(*data); ++data) { + if (!::ASSIMP_strincmp(data, "NUM=", 4)) { data += 4; - me.first = strtoul10(data,&data); - } - else if (!::ASSIMP_strincmp(data,"TEXTURE=",8)) { + me.first = strtoul10(data, &data); + } else if (!::ASSIMP_strincmp(data, "TEXTURE=", 8)) { data += 8; const char *d = data; - for (;!IsSpaceOrNewLine(*data);++data); - me.second = std::string(d,(size_t)(data-d)); + for (; !IsSpaceOrNewLine(*data); ++data) + ; + me.second = std::string(d, (size_t)(data - d)); // try to find matching path names, doesn't care if we don't find them - for (std::vector< std::pair< std::string,std::string > >::const_iterator it = tempTextures.begin(); - it != tempTextures.end(); ++it) { - if ((*it).first == me.second) { + for (std::vector>::const_iterator it = tempTextures.begin(); + it != tempTextures.end(); ++it) { + if ((*it).first == me.second) { me.second = (*it).second; break; } } } } - } - else if (TokenMatchI(data,"SCALE",5)) { + } else if (TokenMatchI(data, "SCALE", 5)) { - for (;!IsLineEnd(*data);++data) { - if (data[0] == 'X' && data[1] == '=') { - data = fast_atoreal_move(data+2,(float&)nd->mTransformation.a1); - } - else if (data[0] == 'Y' && data[1] == '=') { - data = fast_atoreal_move(data+2,(float&)nd->mTransformation.b2); - } - else if (data[0] == 'Z' && data[1] == '=') { - data = fast_atoreal_move(data+2,(float&)nd->mTransformation.c3); + for (; !IsLineEnd(*data); ++data) { + if (data[0] == 'X' && data[1] == '=') { + data = fast_atoreal_move(data + 2, (float &)nd->mTransformation.a1); + } else if (data[0] == 'Y' && data[1] == '=') { + data = fast_atoreal_move(data + 2, (float &)nd->mTransformation.b2); + } else if (data[0] == 'Z' && data[1] == '=') { + data = fast_atoreal_move(data + 2, (float &)nd->mTransformation.c3); } } } } } } - } - else { + } else { ASSIMP_LOG_ERROR("Unable to open .uc file"); } std::vector materials; - materials.reserve(textures.size()*2+5); + materials.reserve(textures.size() * 2 + 5); // find out how many output meshes and materials we'll have and build material indices - for (Unreal::Triangle &tri : triangles) { + for (Unreal::Triangle &tri : triangles) { Unreal::TempMat mat(tri); - std::vector::iterator nt = std::find(materials.begin(),materials.end(),mat); + std::vector::iterator nt = std::find(materials.begin(), materials.end(), mat); if (nt == materials.end()) { // add material tri.matIndex = static_cast(materials.size()); @@ -426,9 +414,8 @@ void UnrealImporter::InternReadFile( const std::string& pFile, materials.push_back(mat); ++pScene->mNumMeshes; - } - else { - tri.matIndex = static_cast(nt-materials.begin()); + } else { + tri.matIndex = static_cast(nt - materials.begin()); ++nt->numFaces; } } @@ -438,65 +425,65 @@ void UnrealImporter::InternReadFile( const std::string& pFile, } // allocate meshes and bind them to the node graph - pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]; - pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes]; + pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; + pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = pScene->mNumMeshes]; - nd->mNumMeshes = pScene->mNumMeshes; + nd->mNumMeshes = pScene->mNumMeshes; nd->mMeshes = new unsigned int[nd->mNumMeshes]; - for (unsigned int i = 0; i < pScene->mNumMeshes;++i) { - aiMesh* m = pScene->mMeshes[i] = new aiMesh(); + for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { + aiMesh *m = pScene->mMeshes[i] = new aiMesh(); m->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; const unsigned int num = materials[i].numFaces; - m->mFaces = new aiFace [num]; - m->mVertices = new aiVector3D [num*3]; - m->mTextureCoords[0] = new aiVector3D [num*3]; + m->mFaces = new aiFace[num]; + m->mVertices = new aiVector3D[num * 3]; + m->mTextureCoords[0] = new aiVector3D[num * 3]; nd->mMeshes[i] = i; // create materials, too - aiMaterial* mat = new aiMaterial(); + aiMaterial *mat = new aiMaterial(); pScene->mMaterials[i] = mat; // all white by default - texture rulez - aiColor3D color(1.f,1.f,1.f); + aiColor3D color(1.f, 1.f, 1.f); aiString s; - ::ai_snprintf( s.data, MAXLEN, "mat%u_tx%u_",i,materials[i].tex ); + ::ai_snprintf(s.data, MAXLEN, "mat%u_tx%u_", i, materials[i].tex); // set the two-sided flag if (materials[i].type == Unreal::MF_NORMAL_TS) { const int twosided = 1; - mat->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED); - ::strcat(s.data,"ts_"); - } - else ::strcat(s.data,"os_"); + mat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED); + ::strcat(s.data, "ts_"); + } else + ::strcat(s.data, "os_"); // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us - if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) { + if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) { const float opac = 0.9f; - mat->AddProperty(&opac,1,AI_MATKEY_OPACITY); - ::strcat(s.data,"tran_"); - } - else ::strcat(s.data,"opaq_"); + mat->AddProperty(&opac, 1, AI_MATKEY_OPACITY); + ::strcat(s.data, "tran_"); + } else + ::strcat(s.data, "opaq_"); // a special name for the weapon attachment point if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) { - s.length = ::ai_snprintf( s.data, MAXLEN, "$WeaponTag$" ); - color = aiColor3D(0.f,0.f,0.f); + s.length = ::ai_snprintf(s.data, MAXLEN, "$WeaponTag$"); + color = aiColor3D(0.f, 0.f, 0.f); } // set color and name - mat->AddProperty(&color,1,AI_MATKEY_COLOR_DIFFUSE); + mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE); s.length = static_cast(::strlen(s.data)); - mat->AddProperty(&s,AI_MATKEY_NAME); + mat->AddProperty(&s, AI_MATKEY_NAME); // set texture, if any const unsigned int tex = materials[i].tex; - for (std::vector< std::pair< unsigned int, std::string > >::const_iterator it = textures.begin();it != textures.end();++it) { + for (std::vector>::const_iterator it = textures.begin(); it != textures.end(); ++it) { if ((*it).first == tex) { s.Set((*it).second); - mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0)); + mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0)); break; } } @@ -505,17 +492,17 @@ void UnrealImporter::InternReadFile( const std::string& pFile, // fill them. for (const Unreal::Triangle &tri : triangles) { Unreal::TempMat mat(tri); - std::vector::iterator nt = std::find(materials.begin(),materials.end(),mat); + std::vector::iterator nt = std::find(materials.begin(), materials.end(), mat); - aiMesh* mesh = pScene->mMeshes[nt-materials.begin()]; - aiFace& f = mesh->mFaces[mesh->mNumFaces++]; - f.mIndices = new unsigned int[f.mNumIndices = 3]; + aiMesh *mesh = pScene->mMeshes[nt - materials.begin()]; + aiFace &f = mesh->mFaces[mesh->mNumFaces++]; + f.mIndices = new unsigned int[f.mNumIndices = 3]; - for (unsigned int i = 0; i < 3;++i,mesh->mNumVertices++) { + for (unsigned int i = 0; i < 3; ++i, mesh->mNumVertices++) { f.mIndices[i] = mesh->mNumVertices; - mesh->mVertices[mesh->mNumVertices] = vertices[ tri.mVertex[i] ]; - mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D( tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f); + mesh->mVertices[mesh->mNumVertices] = vertices[tri.mVertex[i]]; + mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D(tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f); } } diff --git a/code/Unreal/UnrealLoader.h b/code/Unreal/UnrealLoader.h index e758e815a..f1070fbba 100644 --- a/code/Unreal/UnrealLoader.h +++ b/code/Unreal/UnrealLoader.h @@ -62,41 +62,38 @@ public: * * See BaseImporter::CanRead() for details. **/ - bool CanRead( const std::string& pFile, IOSystem* pIOHandler, - bool checkSig) const; + bool CanRead(const std::string &pFile, IOSystem *pIOHandler, + bool checkSig) const; protected: - // ------------------------------------------------------------------- /** @brief Called by Importer::GetExtensionList() * * See #BaseImporter::GetInfo for the details */ - const aiImporterDesc* GetInfo () const; - + const aiImporterDesc *GetInfo() const; // ------------------------------------------------------------------- /** @brief Setup properties for the importer * * See BaseImporter::SetupProperties() for details */ - void SetupProperties(const Importer* pImp); + void SetupProperties(const Importer *pImp); // ------------------------------------------------------------------- /** @brief Imports the given file into the given scene structure. * * See BaseImporter::InternReadFile() for details */ - void InternReadFile( const std::string& pFile, aiScene* pScene, - IOSystem* pIOHandler); + void InternReadFile(const std::string &pFile, aiScene *pScene, + IOSystem *pIOHandler); private: - //! frame to be loaded - uint32_t configFrameID; + uint32_t mConfigFrameID; //! process surface flags - bool configHandleFlags; + bool mConfigHandleFlags; }; // !class UnrealImporter