summaryrefslogtreecommitdiff
path: root/src/mesh/assimp-master/code/AssetLib/Unreal
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/Unreal')
-rw-r--r--src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.cpp521
-rw-r--r--src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.h102
2 files changed, 623 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.cpp b/src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.cpp
new file mode 100644
index 0000000..661952b
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.cpp
@@ -0,0 +1,521 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file UnrealLoader.cpp
+ * @brief Implementation of the UNREAL (*.3D) importer class
+ *
+ * Sources:
+ * http://local.wasp.uwa.edu.au/~pbourke/dataformats/unreal/
+ */
+
+#ifndef ASSIMP_BUILD_NO_3D_IMPORTER
+
+#include "AssetLib/Unreal/UnrealLoader.h"
+#include "PostProcessing/ConvertToLHProcess.h"
+
+#include <assimp/ParsingUtils.h>
+#include <assimp/StreamReader.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
+
+#include <cstdint>
+#include <memory>
+
+using namespace Assimp;
+
+namespace Unreal {
+
+/*
+ 0 = Normal one-sided
+ 1 = Normal two-sided
+ 2 = Translucent two-sided
+ 3 = Masked two-sided
+ 4 = Modulation blended two-sided
+ 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
+};
+
+// 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;
+};
+
+// temporary representation for a material
+struct TempMat {
+ TempMat() :
+ type(MF_NORMAL_OS), tex(), numFaces(0) {}
+
+ explicit TempMat(const Triangle &in) :
+ type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {}
+
+ // type of mesh
+ Unreal::MeshFlags type;
+
+ // index of texture
+ unsigned int tex;
+
+ // number of faces using us
+ unsigned int numFaces;
+
+ // 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;
+};
+
+// UNREAL vertex compression
+inline void CompressVertex(const aiVector3D &v, uint32_t &out) {
+ 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));
+}
+
+// UNREAL vertex decompression
+inline void DecompressVertex(aiVector3D &v, int32_t in) {
+ union {
+ Vertex n;
+ int32_t i;
+ };
+ i = in;
+
+ v.x = (float)n.X;
+ v.y = (float)n.Y;
+ v.z = (float)n.Z;
+}
+
+} // end namespace Unreal
+
+static const aiImporterDesc desc = {
+ "Unreal Mesh Importer",
+ "",
+ "",
+ "",
+ aiImporterFlags_SupportTextFlavour,
+ 0,
+ 0,
+ 0,
+ 0,
+ "3d uc"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+UnrealImporter::UnrealImporter() :
+ mConfigFrameID(0), mConfigHandleFlags(true) {
+ // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+UnrealImporter::~UnrealImporter() {
+ // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool UnrealImporter::CanRead(const std::string & filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+ return SimpleExtensionCheck(filename, "3d", "uc");
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build a string of all file extensions supported
+const aiImporterDesc *UnrealImporter::GetInfo() const {
+ return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup configuration properties for the loader
+void UnrealImporter::SetupProperties(const Importer *pImp) {
+ // The
+ // AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the
+ // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
+ mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME, -1);
+ if (static_cast<unsigned int>(-1) == mConfigFrameID) {
+ mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
+ }
+
+ // AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true
+ 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) {
+ // 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") {
+ // 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);
+ }
+
+ // build proper paths
+ d_path = extension + "_d.3d";
+ a_path = extension + "_a.3d";
+ uc_path = extension + ".uc";
+
+ ASSIMP_LOG_DEBUG("UNREAL: data file is ", d_path);
+ ASSIMP_LOG_DEBUG("UNREAL: aniv file is ", a_path);
+ ASSIMP_LOG_DEBUG("UNREAL: uc file is ", uc_path);
+
+ // and open the files ... we can't live without them
+ std::unique_ptr<IOStream> p(pIOHandler->Open(d_path));
+ if (!p)
+ throw DeadlyImportError("UNREAL: Unable to open _d file");
+ StreamReaderLE d_reader(pIOHandler->Open(d_path));
+
+ const uint16_t numTris = d_reader.GetI2();
+ const uint16_t numVert = d_reader.GetI2();
+ d_reader.IncPtr(44);
+ if (!numTris || numVert < 3)
+ throw DeadlyImportError("UNREAL: Invalid number of vertices/triangles");
+
+ // maximum texture index
+ unsigned int maxTexIdx = 0;
+
+ // collect triangles
+ std::vector<Unreal::Triangle> triangles(numTris);
+ for (auto &tri : triangles) {
+ for (unsigned int i = 0; i < 3; ++i) {
+
+ tri.mVertex[i] = d_reader.GetI2();
+ if (tri.mVertex[i] >= numTris) {
+ ASSIMP_LOG_WARN("UNREAL: vertex index out of range");
+ tri.mVertex[i] = 0;
+ }
+ }
+ tri.mType = d_reader.GetI1();
+
+ // handle mesh flagss?
+ if (mConfigHandleFlags)
+ tri.mType = Unreal::MF_NORMAL_OS;
+ else {
+ // ignore MOD and MASKED for the moment, treat them as two-sided
+ if (tri.mType == Unreal::MF_NORMAL_MOD_TS || tri.mType == Unreal::MF_NORMAL_MASKED_TS)
+ tri.mType = Unreal::MF_NORMAL_TS;
+ }
+ d_reader.IncPtr(1);
+
+ 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);
+ d_reader.IncPtr(1);
+ }
+
+ p.reset(pIOHandler->Open(a_path));
+ if (!p)
+ throw DeadlyImportError("UNREAL: Unable to open _a file");
+ StreamReaderLE a_reader(pIOHandler->Open(a_path));
+
+ // read number of frames
+ const uint32_t numFrames = a_reader.GetI2();
+ if (mConfigFrameID >= numFrames) {
+ throw DeadlyImportError("UNREAL: The requested frame does not exist");
+ }
+
+ uint32_t st = a_reader.GetI2();
+ if (st != numVert * 4u)
+ throw DeadlyImportError("UNREAL: Unexpected aniv file length");
+
+ // skip to our frame
+ a_reader.IncPtr(mConfigFrameID * numVert * 4);
+
+ // collect vertices
+ std::vector<aiVector3D> vertices(numVert);
+ for (auto &vertex : vertices) {
+ int32_t val = a_reader.GetI4();
+ Unreal::DecompressVertex(vertex, val);
+ }
+
+ // list of textures.
+ std::vector<std::pair<unsigned int, std::string>> textures;
+
+ // allocate the output scene
+ aiNode *nd = pScene->mRootNode = new aiNode();
+ nd->mName.Set("<UnrealRoot>");
+
+ // we can live without the uc file if necessary
+ std::unique_ptr<IOStream> pb(pIOHandler->Open(uc_path));
+ if (pb.get()) {
+
+ std::vector<char> _data;
+ TextFileToBuffer(pb.get(), _data);
+ const char *data = &_data[0];
+
+ std::vector<std::pair<std::string, std::string>> tempTextures;
+
+ // do a quick search in the UC file for some known, usually texture-related, tags
+ for (; *data; ++data) {
+ if (TokenMatchI(data, "#exec", 5)) {
+ SkipSpacesAndLineEnd(&data);
+
+ // #exec TEXTURE IMPORT [...] NAME=jjjjj [...] FILE=jjjj.pcx [...]
+ 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 (!me.first.length() || !me.second.length())
+ tempTextures.pop_back();
+ }
+ }
+ // #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)) {
+ SkipSpacesAndLineEnd(&data);
+
+ if (TokenMatchI(data, "SETTEXTURE", 10)) {
+
+ textures.push_back(std::pair<unsigned int, std::string>());
+ std::pair<unsigned int, std::string> &me = textures.back();
+
+ for (; !IsLineEnd(*data); ++data) {
+ if (!::ASSIMP_strincmp(data, "NUM=", 4)) {
+ data += 4;
+ 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));
+
+ // 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) {
+ me.second = (*it).second;
+ break;
+ }
+ }
+ }
+ }
+ } else if (TokenMatchI(data, "SCALE", 5)) {
+
+ for (; !IsLineEnd(*data); ++data) {
+ if (data[0] == 'X' && data[1] == '=') {
+ data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.a1);
+ } else if (data[0] == 'Y' && data[1] == '=') {
+ data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.b2);
+ } else if (data[0] == 'Z' && data[1] == '=') {
+ data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.c3);
+ }
+ }
+ }
+ }
+ }
+ }
+ } else {
+ ASSIMP_LOG_ERROR("Unable to open .uc file");
+ }
+
+ std::vector<Unreal::TempMat> materials;
+ 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) {
+ Unreal::TempMat mat(tri);
+ std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(), materials.end(), mat);
+ if (nt == materials.end()) {
+ // add material
+ tri.matIndex = static_cast<unsigned int>(materials.size());
+ mat.numFaces = 1;
+ materials.push_back(mat);
+
+ ++pScene->mNumMeshes;
+ } else {
+ tri.matIndex = static_cast<unsigned int>(nt - materials.begin());
+ ++nt->numFaces;
+ }
+ }
+
+ if (!pScene->mNumMeshes) {
+ throw DeadlyImportError("UNREAL: Unable to find valid mesh data");
+ }
+
+ // allocate meshes and bind them to the node graph
+ pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+ pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = 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();
+ 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];
+
+ nd->mMeshes[i] = i;
+
+ // create materials, too
+ aiMaterial *mat = new aiMaterial();
+ pScene->mMaterials[i] = mat;
+
+ // all white by default - texture rulez
+ aiColor3D color(1.f, 1.f, 1.f);
+
+ aiString s;
+ ::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_");
+
+ // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us
+ 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_");
+
+ // 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);
+ }
+
+ // set color and name
+ mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
+ s.length = static_cast<ai_uint32>(::strlen(s.data));
+ 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) {
+ if ((*it).first == tex) {
+ s.Set((*it).second);
+ mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
+ break;
+ }
+ }
+ }
+
+ // fill them.
+ for (const Unreal::Triangle &tri : triangles) {
+ Unreal::TempMat mat(tri);
+ std::vector<Unreal::TempMat>::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];
+
+ 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);
+ }
+ }
+
+ // convert to RH
+ MakeLeftHandedProcess hero;
+ hero.Execute(pScene);
+
+ FlipWindingOrderProcess flipper;
+ flipper.Execute(pScene);
+}
+
+#endif // !! ASSIMP_BUILD_NO_3D_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.h b/src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.h
new file mode 100644
index 0000000..a931a86
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Unreal/UnrealLoader.h
@@ -0,0 +1,102 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file UnrealLoader.h
+ * @brief Declaration of the .3d (UNREAL) importer class.
+ */
+#ifndef INCLUDED_AI_3D_LOADER_H
+#define INCLUDED_AI_3D_LOADER_H
+
+#include <assimp/BaseImporter.h>
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/**
+ * @brief Importer class to load UNREAL files (*.3d)
+ */
+class UnrealImporter : public BaseImporter {
+public:
+ UnrealImporter();
+ ~UnrealImporter();
+
+ // -------------------------------------------------------------------
+ /** @brief Returns whether we can handle the format of the given file
+ *
+ * See BaseImporter::CanRead() for details.
+ **/
+ bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+ // -------------------------------------------------------------------
+ /** @brief Called by Importer::GetExtensionList()
+ *
+ * @see #BaseImporter::GetInfo for the details
+ */
+ const aiImporterDesc *GetInfo() const override;
+
+ // -------------------------------------------------------------------
+ /** @brief Setup properties for the importer
+ *
+ * See BaseImporter::SetupProperties() for details
+ */
+ void SetupProperties(const Importer *pImp) override;
+
+ // -------------------------------------------------------------------
+ /** @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) override;
+
+private:
+ //! frame to be loaded
+ uint32_t mConfigFrameID;
+
+ //! process surface flags
+ bool mConfigHandleFlags;
+
+}; // !class UnrealImporter
+
+} // end of namespace Assimp
+
+#endif // AI_UNREALIMPORTER_H_INC
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-26 01:10:07 +0000