v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

JT: Inital commit.

pull/2529/head
Kim Kulling 2019-06-06 08:29:12 +02:00
parent b03b3b9c03
commit 6ed4f5d936
3 changed files with 394 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
code/FBXConverter.h
View File

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

186
code/JTImporter.cpp 100644
View File

@ -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

207
code/JTImporter.h 100644
View File

@ -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