.lmt - Synthlight/MHW-Editor GitHub Wiki

//------------------------------------------------
//--- 010 Editor v8.0.1 Binary Template
//
//      File: LinkMotion
//   Authors: CrazyT
//   Version: 
//   Purpose: 
//  Category: 
// File Mask: *.lmt
//  ID Bytes: 
//   History: DorfDork: Fixed up some issues with buffer, Add struct for Events
//------------------------------------------------

local int i;
local int j;
local int k;
local int NumOfAnimations;
local int maxj = 0;
local int cursize;

//LMTEvents
//------------------------------------------------

typedef struct {
	uint64 EventDataOffset<format = hex>;
	uint64 EventDataCount;
    ubyte Type[8]<format = hex>;
} EventParams;

typedef struct {
	uint64 EventParamOffset<format = hex>;
	uint64 EventParamCount;
	int unk1;
	int unk2;
	float unk3;
	float unk4;
	int unk5;
	int unk6;
	int unk7;
	int unk8;
	EventParams Params[EventParamCount];
} LMTEvents;

typedef struct {
	local int EventCorrection;
	for(i=0;i<NumOfAnimations;i++){
        if(Animation.AniData[i].EventsOffset==0)continue;
        FSeek(Animation.AniData[i].EventsOffset);
        LMTEvents EventData;
        for (j=0;j<EventData.EventParamCount;j++){
            FSeek(EventData.Params[j].EventDataOffset);
            uint64 ParamDataInnerOffset<format = hex>;
            uint64 ParamDataInnerCount;
            uint OuterUnk1;
            uint OuterUnk2;
            uint OuterUnk3;
            uint OuterUnk4;
            FSeek(ParamDataInnerOffset);
            for (k=0;k<ParamDataInnerCount;k++){
                uint InnerData1<bgcolor=0x000000>;
                uint InnerData2<bgcolor=0x000000>;
                uint InnerData3<bgcolor=0x000000>;
                uint InnerData4<bgcolor=0x000000>;
                uint InnerData5<bgcolor=0x000000>;
            }
        }
    }
} LMTEventBlock;
//------------------------------------------------


//LMTBuffer
//------------------------------------------------
struct LMTVec3{
	float x;
	float y;
	float z;
};

struct LMTQuadraticVector3{
	byte addcount;
	byte flags;
	short s;
	float vx;
	float vy;
	float vz;
	local int i=0;
	float f[8];
};
struct LMTVec3Frame{
	float x;
	float y;
	float z;
};
struct LMTQuatized8Vec3{
	byte f[3];
	byte reframe;
};
struct LMTQuatized16Vec3{
	short f[3];
	short relframe;
};
struct LMTQuat3Frame{
	float f[3];
	long l;
};
struct LMTQuatFramev14{
	long l1;
	long l2;
};
struct LMTQuatized32Quat{
	long l;
};
struct LMTXWQuat{
	long l;
};
struct LMTYWQuat{
	long l;
};
struct LMTZWQuat{
	long l;
};
struct LMTQuatized11Quat{
	short s[3];
};
struct LMTQuatized9Quat{
	byte b[5];
};

typedef struct {
	for(j=0;j<maxj;j++){
		if(KeyFrame.kbr[j].BufferOffset==0)continue;
		if(KeyFrame.kbr[j].BufferSize==0)continue;
		FSeek(KeyFrame.kbr[j].BufferOffset);
		cursize = 0;
        if (j == 0) Printf("%x", KeyFrame.kbr[0].BufferSize);
		struct {
			local int BufferSize = KeyFrame.kbr[j].BufferSize;
			while(cursize < BufferSize){
				if(KeyFrame.kbr[j].BufferType == 1){
					LMTVec3 vec;
					cursize += sizeof(vec);
				}
				else if(KeyFrame.kbr[j].BufferType == 2){
					LMTVec3Frame vec;
					cursize += sizeof(vec);
				}
				else if(KeyFrame.kbr[j].BufferType == 3){
					LMTVec3Frame vec;
					cursize += sizeof(vec);
				}
				else if(KeyFrame.kbr[j].BufferType == 4){
					LMTQuatized16Vec3 q;
					cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 5){
					LMTQuatized8Vec3 q;
					cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 6){
					LMTQuatFramev14 f;
					cursize += sizeof(f);
				}
				else if(KeyFrame.kbr[j].BufferType == 7){
					LMTQuatized32Quat q;
					cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 9){
					LMTVec3Frame vec;
					cursize += sizeof(vec);
				}
				else if(KeyFrame.kbr[j].BufferType == 11){
					LMTXWQuat q;
					cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 12){
					LMTYWQuat q;
					cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 13){
					LMTZWQuat q;
					cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 14){
				LMTQuatized11Quat q;
				cursize += sizeof(q);
				}
				else if(KeyFrame.kbr[j].BufferType == 15){
					LMTQuatized9Quat q;
					cursize += sizeof(q);
				}else {
					cursize +=1;
				}
			}
		} Buffer;
	}
} LMTBuffer;
//------------------------------------------------

//LMTKeyFrameBounds
//------------------------------------------------
typedef struct {
	for(j=0;j<maxj;j++){
		if(KeyFrame.kbr[j].BoundsOffset==0)continue;
		FSeek(KeyFrame.kbr[j].BoundsOffset);
		struct LMTKeyframeBounds{
			float Mult[4];
			float Add[4];
		} Bounds;
	}
} LMTKeyFrameBounds;
//------------------------------------------------


//LMTKeyFrameBlock
//------------------------------------------------
typedef struct {
	ubyte BufferType;
	ubyte Usage;
	ubyte JointType;
	ubyte unk;
	int BoneID;
	float Weight;
	int BufferSize;
	uint64 BufferOffset<format = hex>;
	float RefrenceFrame[4];
	uint64 BoundsOffset<format = hex>;
} LMTKeyFrameData;

string readKBR(LMTKeyFrameData &x){
    string s;
    SPrintf( s, "BoundsOffset:%08x%08x BufferOffset:%08x%08x BufferType:%x",x.BoundsOffset>>32,x.BoundsOffset,x.BoundsOffset>>32,x.BoundsOffset,x.BufferType);
    return s;
}

typedef struct {
	local int AnimationCorrection;
	for(i=0;i<NumOfBlocks;i++){
		if(Offsets[i]==0){
			AnimationCorrection++;
			continue;
		}
		if(Animation.AniData[i-AnimationCorrection].BonePathsOffset==0) continue;
		FSeek(Animation.AniData[i-AnimationCorrection].BonePathsOffset); //Goes to the LMTAniBlock and pulls bone data
		for(j=0;j<Animation.AniData[i-AnimationCorrection].NumOfBonePaths;j++) {
			LMTKeyFrameData kbr<read=readKBR>;
			maxj++;
		}
	}
} LMTKeyFrameBlock;
//------------------------------------------------


//LMTAniBlock
//------------------------------------------------
typedef struct {
	for (i=0; i<NumOfBlocks; i++) {
		if (Offsets[i]==0) continue; //Skips offset with no value
		struct LMTAniData {
			uint64 BonePathsOffset<format = hex>;
			long NumOfBonePaths;
			long NumOfFrames;
			long LoopFrame;
			uint unk1;
			uint unk2;
			uint unk3;
			float unk4;
			float unk5;
			float unk6;
			uint unk7;
			uint unk8;
			float unk9;
			uint unk10;
			float unk11;
			uint unk12;
			float unk13;
			uint unk14;
			uint unk15;
			uint unk16;
			uint unk17;
			uint64 EventsOffset<format = hex>;
		} AniData;
        NumOfAnimations++;
    }
} LMTAniBlock;
//------------------------------------------------

string LMT <optimize=false>;
short Version;
short NumOfBlocks;
uint64 unk1;
uint64 Offsets[NumOfBlocks]<format = hex, bgcolor=0x00ff00>;
LMTAniBlock Animation<bgcolor=0xff0000>;
LMTKeyFrameBlock KeyFrame<bgcolor=0x0000ff>;
LMTKeyFrameBounds KeyBounds<bgcolor=0x00ffff>;
LMTBuffer Buffers<bgcolor=0xFFFF00>;
LMTEventBlock Events<bgcolor=0x802060>;