JT: Inital commit.

code/FBXConverter.h

@@ -52,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXUtil.h"
 #include "FBXProperties.h"
 #include "FBXImporter.h"
+
 #include <assimp/anim.h>
 #include <assimp/material.h>
 #include <assimp/light.h>

code/JTImporter.cpp

@@ -0,0 +1,186 @@
+#include "JTImporter.h"
+
+#include <assimp/StreamReader.h>
+#include <assimp/MemoryIOWrapper.h>
+#include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/ai_assert.h>
+
+#ifndef ASSIMP_BUILD_NO_JT_IMPORTER
+
+namespace Assimp {
+
+namespace {
+
+    static const aiImporterDesc desc = {
+        "Siemens JF File format importer",
+        "",
+        "",
+        "",
+        aiImporterFlags_SupportTextFlavour,
+        0,
+        0,
+        0,
+        0,
+        "jt"
+    };
+}
+
+enum SegmentType {
+    SceneGraph = 1,
+    JT_B_Rep,
+    PMI_Data,
+    MetaData,
+    Shape,
+    Shape_LOD0,
+    Shape_LOD1,
+    Shape_LOD2,
+    Shape_LOD3,
+    Shape_LOD4,
+    Shape_LOD5,
+    Shape_LOD6,
+    Shape_LOD7,
+    Shape_LOD8,
+    Shape_LOD9,
+    XT_B_Rep,
+    Wireframe_Rep,
+    ULP,
+    LWPA
+};
+
+JTImporter::JTImporter()
+: BaseImporter()
+, mJTModel()
+, mDataSegments()
+, mCurrentDataSegment( nullptr ){
+    // empty
+}
+
+JTImporter::~JTImporter() {
+    // empty
+}
+
+bool JTImporter::CanRead(const std::string &file, IOSystem* pIOHandler, bool checkSig) const {
+    const std::string& extension = GetExtension(file);
+    if (extension == std::string(desc.mFileExtensions)) {
+        return true;
+    }
+
+    return false;
+}
+
+const aiImporterDesc* JTImporter::GetInfo() const {
+    return &desc;
+}
+
+void JTImporter::InternReadFile(const std::string &file, aiScene* pScene, IOSystem* pIOHandler) {
+
+    std::unique_ptr<IOStream> stream(pIOHandler->Open(file, "rb"));
+    if (!stream) {
+        throw DeadlyImportError("JT: Cannot open file " + file );
+    }
+
+    std::vector<char> contents;
+    contents.resize(stream->FileSize() + 1);
+    stream->Read(&*contents.begin(), 1, contents.size() - 1);
+    contents[contents.size() - 1] = 0;
+    BinReader reader(contents);
+    ReadHeader(reader);
+}
+
+void JTImporter::ReadHeader(BinReader& reader) {
+    reader.readChars(VersionLen, mJTModel.mJTHeader.mVersion);
+    reader.readUChar(mJTModel.mJTHeader.mByteOrder);
+    reader.readI32(mJTModel.mJTHeader.mReserved);
+
+    int toc_offset;
+    reader.readI32(toc_offset);
+}
+
+void JTImporter::ReadTokenSegment(BinReader& reader) {
+    int toc_count;
+    reader.readI32(toc_count);
+    if (0 == toc_count) {
+        return;
+    }
+
+    for (int i = 0; i < toc_count; ++i) {
+        ReadTokenEntry(reader);
+    }
+}
+
+void JTImporter::ReadTokenEntry(BinReader& reader) {
+    TokenEntry* entry = new TokenEntry;
+    reader.readGUID(entry->guid);
+    reader.readI32(entry->offset);
+    reader.readI32(entry->length);
+    reader.readU32(entry->attributes);
+
+    mJTModel.mTokenEntryMap[entry->guid] = entry;
+}
+
+TokenEntry* JTImporter::FindTokenEntryByGuid(GUID& guid) {
+    if (mJTModel.mTokenEntryMap.empty()) {
+        return nullptr;
+    }
+
+    JTModel::TokenEntryMap::const_iterator it(mJTModel.mTokenEntryMap.find(guid));
+    if (it == mJTModel.mTokenEntryMap.end()) {
+        return nullptr;
+    }
+
+    return it->second;
+}
+
+static bool SupportsZlibCompression(SegmentType type) {
+    switch (type) {
+        case SceneGraph:
+        case JT_B_Rep:
+        case PMI_Data:
+        case MetaData:
+            return true;
+        case Shape:
+        case Shape_LOD0:
+        case Shape_LOD1:
+        case Shape_LOD2:
+        case Shape_LOD3:
+        case Shape_LOD4:
+        case Shape_LOD5:
+        case Shape_LOD6:
+        case Shape_LOD7:
+        case Shape_LOD8:
+        case Shape_LOD9:
+            return false;
+        case XT_B_Rep:
+        case Wireframe_Rep:
+        case ULP:
+        case LWPA:
+            return true;
+        default:
+            ai_assert_entry();
+            break;
+    }
+
+    return false;
+}
+
+void JTImporter::ReadDataSegment(BinReader& reader) {
+    mCurrentDataSegment = new DataSegment;
+    mDataSegments.push_back(mCurrentDataSegment);
+    ReadDataSegmentHeader(reader);
+
+}
+
+void JTImporter::ReadDataSegmentHeader(BinReader& reader) {
+    if (nullptr == mCurrentDataSegment) {
+        return;
+    }
+
+    reader.readGUID(mCurrentDataSegment->m_DataSegmentHeader.guid);
+    reader.readI32(mCurrentDataSegment->m_DataSegmentHeader.type);
+    reader.readI32(mCurrentDataSegment->m_DataSegmentHeader.length);
+}
+
+} // end namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_JT_IMPORTER

code/JTImporter.h

@@ -0,0 +1,207 @@
+#pragma once
+#ifndef AI_JTIMPORTER_H_INC
+#define AI_JTIMPORTER_H_INC
+
+#include <assimp/BaseImporter.h>
+
+#include <vector>
+#include <map>
+
+#ifndef ASSIMP_BUILD_NO_JT_IMPORTER
+
+namespace Assimp {
+
+using i32 = int;
+using u32 = unsigned int;
+using i16 = short;
+using u16 = unsigned short;
+using c8 = char;
+using u8 = unsigned char;
+using f32 = float;
+using f64 = double;
+
+static const size_t VersionLen = 80u;
+
+struct JTHeader {
+    char mVersion[VersionLen];
+    unsigned char mByteOrder;
+    int mReserved;
+    int toc_offset;
+};
+
+template<class T>
+struct TJTCoord {
+    T x, y, z;
+};
+
+using F32Coord = TJTCoord<f32>;
+using F64Coord = TJTCoord<f64>;
+
+struct BBox32 {
+    F32Coord min;
+    F32Coord max;
+};
+
+template<class T>
+struct THJTCoord {
+    T x, y, z, w;
+};
+
+using F32HCoord = THJTCoord<f32>;
+using F64HCoord = THJTCoord<f64>;
+
+struct MbString {
+    int count;
+    char *data;
+};
+
+struct String {
+    int count;
+    char* data;
+};
+
+template<class T>
+struct TVec {
+    int count;
+    T *data;
+};
+
+using VecF32 = TVec<f32>;
+using VecF64 = TVec<f64>;
+using VecI32 = TVec<i32>;
+
+struct RGB {
+    f32 data[3];
+};
+
+struct RGBA {
+    f32 data[4];
+ };
+
+struct GUID {
+    unsigned int id1;
+    u16 id2[2];
+    u8 id3[8];
+};
+
+struct GUIDComparer {
+    bool operator() (const GUID& lhs, const GUID& rhs) const {
+        if (lhs.id1 < rhs.id1) {
+            return true;
+        }
+
+        for (size_t i = 0; i < 2; ++i) {
+            if (lhs.id2[i] < rhs.id2[i]) {
+                return true;
+            }
+        }
+
+        for (size_t i = 0; i < 8; ++i) {
+            if (lhs.id3[i] < rhs.id3[i]) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+};
+
+struct TokenEntry {
+    GUID guid;
+    i32 offset;
+    i32 length;
+    u32 attributes;
+};
+
+struct DataSegmentHeader {
+    GUID guid;
+    i32 type;
+    i32 length;
+};
+
+struct DataSegment {
+    DataSegmentHeader m_DataSegmentHeader;
+};
+
+struct ElementHeader {
+    GUID obj_type_id;
+    u8 obj_base_type;
+    i32 obj_id;
+};
+
+struct JTModel {
+    JTHeader mJTHeader;
+    GUID mGUID;
+    using TokenEntryMap = std::map<GUID, TokenEntry*, GUIDComparer>;
+    TokenEntryMap mTokenEntryMap;
+};
+
+class BinReader {
+    std::vector<char>& mData;
+    size_t mOffset;
+
+public:
+    BinReader(std::vector<char>& data)
+    : mData(data)
+    , mOffset(0u){
+        // empty
+    }
+
+    void readChars(size_t numChars, char* buffer) {
+        ::memcpy(buffer, &mData[mOffset], numChars);
+        mOffset += numChars;
+    }
+
+    void readUChar(unsigned char &c) {
+        ::memcpy(&c, &mData[mOffset], sizeof(unsigned char));
+        mOffset += sizeof(unsigned char);
+    }
+
+    void readI32(int32_t& v) {
+        ::memcpy(&v, &mData[mOffset], sizeof(int32_t));
+        mOffset += sizeof(int32_t);
+    }
+
+    void readU32(uint32_t& v) {
+        ::memcpy(&v, &mData[mOffset], sizeof(uint32_t));
+        mOffset += sizeof(uint32_t);
+    }
+
+    void readGUID(GUID &guid) {
+        ::memcpy(&guid.id1, &mData[mOffset], sizeof(i32));
+        mOffset += sizeof(i32);
+        ::memcpy(guid.id2, &mData[mOffset], sizeof(u16) * 2);
+        mOffset += sizeof(u16)*2;
+        ::memcpy(guid.id3, &mData[mOffset], sizeof(u8) * 8);
+        mOffset += sizeof(u8) * 8;
+    }
+};
+
+class JTImporter : public BaseImporter {
+public:
+    JTImporter();
+    ~JTImporter();
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const override;
+    const aiImporterDesc* GetInfo() const override;
+
+protected:
+    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) override;
+    void ReadHeader(BinReader &reader);
+    void ReadTokenSegment(BinReader& reader);
+    void ReadTokenEntry(BinReader& reader);
+    TokenEntry* FindTokenEntryByGuid(GUID& id);
+    void ReadDataSegment(BinReader& reader);
+    void ReadDataSegmentHeader(BinReader& reader);
+
+private:
+    JTModel mJTModel;
+    std::vector<DataSegment*> mDataSegments;
+    DataSegment *mCurrentDataSegment;
+
+};
+
+} // end namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_JT_IMPORTER
+
+#endif // AI_JTIMPORTER_H_INC