add assimp submodule

1 files changed, 521 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