From 6ed4f5d936dbd341bc12a19303ec11d7472b568e Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Thu, 6 Jun 2019 08:29:12 +0200 Subject: [PATCH] JT: Inital commit. --- code/FBXConverter.h | 1 + code/JTImporter.cpp | 186 +++++++++++++++++++++++++++++++++++++++ code/JTImporter.h | 207 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 394 insertions(+) create mode 100644 code/JTImporter.cpp create mode 100644 code/JTImporter.h diff --git a/code/FBXConverter.h b/code/FBXConverter.h index f75222d5b..1aa7e13ea 100644 --- a/code/FBXConverter.h +++ b/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 #include #include diff --git a/code/JTImporter.cpp b/code/JTImporter.cpp new file mode 100644 index 000000000..efee4bcb3 --- /dev/null +++ b/code/JTImporter.cpp @@ -0,0 +1,186 @@ +#include "JTImporter.h" + +#include +#include +#include +#include +#include + +#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 stream(pIOHandler->Open(file, "rb")); + if (!stream) { + throw DeadlyImportError("JT: Cannot open file " + file ); + } + + std::vector 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 diff --git a/code/JTImporter.h b/code/JTImporter.h new file mode 100644 index 000000000..821a31032 --- /dev/null +++ b/code/JTImporter.h @@ -0,0 +1,207 @@ +#pragma once +#ifndef AI_JTIMPORTER_H_INC +#define AI_JTIMPORTER_H_INC + +#include + +#include +#include + +#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 +struct TJTCoord { + T x, y, z; +}; + +using F32Coord = TJTCoord; +using F64Coord = TJTCoord; + +struct BBox32 { + F32Coord min; + F32Coord max; +}; + +template +struct THJTCoord { + T x, y, z, w; +}; + +using F32HCoord = THJTCoord; +using F64HCoord = THJTCoord; + +struct MbString { + int count; + char *data; +}; + +struct String { + int count; + char* data; +}; + +template +struct TVec { + int count; + T *data; +}; + +using VecF32 = TVec; +using VecF64 = TVec; +using VecI32 = TVec; + +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; + TokenEntryMap mTokenEntryMap; +}; + +class BinReader { + std::vector& mData; + size_t mOffset; + +public: + BinReader(std::vector& 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 mDataSegments; + DataSegment *mCurrentDataSegment; + +}; + +} // end namespace Assimp + +#endif // ASSIMP_BUILD_NO_JT_IMPORTER + +#endif // AI_JTIMPORTER_H_INC