public static LTBFile Read(FileInfo info)
{
var bFlip = info.Name.StartsWith("PV");
var ltbFile = new LTBFile();
var br = new ExtendedBinaryReader(info.OpenRead());
#region Header
var header = br.ReadUInt16();
if (header > 20)
{
br.Close();
var lzmaStream = new LzmaDecodeStream(info.OpenRead());
var ms = new MemoryStream();
lzmaStream.CopyTo(ms);
if (ms.Length == 0)
{
Console.WriteLine($"{info.Name} is not a vaild LTB file.");
return(null);
}
br = new ExtendedBinaryReader(ms);
br.Skip(0, true);
}
// Skip header
br.Skip(0x14, true);
uint version = br.ReadUInt32();
uint nKeyFrame = br.ReadUInt32();
uint nAnim = br.ReadUInt32();
uint numBones = br.ReadUInt32();
uint nPieces = br.ReadUInt32();
uint nChildModels = br.ReadUInt32();
uint nTris = br.ReadUInt32();
uint nVerts = br.ReadUInt32();
uint nVertexWeights = br.ReadUInt32();
uint nLODs = br.ReadUInt32();
uint nSockets = br.ReadUInt32();
uint nWeightSets = br.ReadUInt32();
uint nStrings = br.ReadUInt32();
uint StringLengths = br.ReadUInt32();
uint VertAnimDataSize = br.ReadUInt32();
uint nAnimData = br.ReadUInt32();
string cmdString = br.ReadStringWithUInt16Length();
float globalRadius = br.ReadSingle();
uint iNumEnabledOBBs = br.ReadUInt32();
if (iNumEnabledOBBs != 0)
{
throw new Exception("LTB with OBB infomations are not supported");
}
uint numMesh = br.ReadUInt32();
#endregion
var romanisation = new McCuneReischauerRomanisation {
PreserveNonKoreanText = true
};
#region Mesh nodes
for (int i = 0; i < numMesh; i++)
{
string meshName = br.ReadStringWithUInt16Length(ltbEncode);
meshName = romanisation.RomaniseText(meshName);
foreach (var kvp in replaceDictionary)
{
meshName = meshName.Replace(kvp.Key, kvp.Value);
}
meshName = meshName.ToLower();
uint numLod = br.ReadUInt32();
Console.WriteLine($"{meshName} - {numLod} Lods");
meshName = meshName.ToLower();
br.Skip((int)numLod * 4 + 8);
int materialIndex = -1;
if (!ltbFile.Materials.Any(material => material.Name == meshName))
{
ltbFile.Materials.Add(new SEModelMaterial
{
Name = "mtl_" + meshName,
MaterialData = new SEModelSimpleMaterial
{
DiffuseMap = meshName + ".png"
}
});
materialIndex = ltbFile.Materials.Count - 1;
}
else
{
materialIndex = ltbFile.Materials.FindIndex(mtl => mtl.Name == meshName);
}
for (int iLod = 0; iLod < numLod; iLod++)
{
var mesh = new SEModelMesh();
mesh.AddMaterialIndex(materialIndex);
var nNumTex = br.ReadUInt32();
const int MAX_PIECE_TEXTURES = 4;
for (int iTex = 0; iTex < MAX_PIECE_TEXTURES; iTex++)
{
// Texture index
br.ReadUInt32();
}
var renderStyle = br.ReadUInt32();
var nRenderPriority = br.ReadByte();
var lodType = (PieceType)br.ReadUInt32();
var lodSize = br.ReadUInt32();
if (lodSize != 0)
{
uint numVerts = br.ReadUInt32();
uint numTris = br.ReadUInt32();
uint iMaxBonesPerTri = br.ReadUInt32();
uint iMaxBonesPerVert = br.ReadUInt32();
Console.WriteLine($" Lod {iLod}: \n Vertex count: {numVerts}\n Triangle count: {numTris}");
bool bReIndexBones = false, bUseMatrixPalettes = false;
if (lodType == PieceType.SkelMesh)
{
bReIndexBones = br.ReadBoolean();
}
DataType[] streamData = { (DataType)br.ReadUInt32(), (DataType)br.ReadUInt32(), (DataType)br.ReadUInt32(), (DataType)br.ReadUInt32() };
uint rigidBone = uint.MaxValue;
if (lodType == PieceType.RigidMesh)
{
rigidBone = br.ReadUInt32();
}
else if (lodType == PieceType.SkelMesh)
{
bUseMatrixPalettes = br.ReadBoolean();
}
else
{
throw new Exception("Unsupported lod type");
}
if (bUseMatrixPalettes)
{
uint iMinBone = br.ReadUInt32();
uint iMaxBone = br.ReadUInt32();
}
var boneMap = new List <uint>();
if (bReIndexBones)
{
uint reindexBoneMapSize = br.ReadUInt32();
for (int iMap = 0; iMap < reindexBoneMapSize; iMap++)
{
boneMap.Add(br.ReadUInt32());
}
}
for (int iStream = 0; iStream < 4; ++iStream)
{
if (!streamData[iStream].HasFlag(DataType.Position))
{
continue;
}
for (int iVert = 0; iVert < numVerts; iVert++)
{
var v = new SEModelVertex();
if (streamData[iStream].HasFlag(DataType.Position))
{
v.Position = new Vector3
{
X = br.ReadSingle(),
Y = br.ReadSingle(),
Z = br.ReadSingle(),
};
if (bFlip)
{
v.Position.X *= -1;
}
if (rigidBone == uint.MaxValue)
{
var weightSum = 0.0f;
var maxWeight = bUseMatrixPalettes ? iMaxBonesPerVert : iMaxBonesPerTri;
for (int iWeight = 0; iWeight < maxWeight - 1; iWeight++)
{
var weight = br.ReadSingle();
if (weight > 1)
{
throw new Exception("wtf");
}
weightSum += weight;
v.Weights.Add(new SEModelWeight
{
BoneIndex = uint.MaxValue,
BoneWeight = weight
});
}
if (1.0f - weightSum > float.Epsilon)
{
v.Weights.Add(new SEModelWeight
{
BoneIndex = uint.MaxValue,
BoneWeight = 1.0f - weightSum
});
}
if (bUseMatrixPalettes)
{
for (int iWeight = 0; iWeight < 4; iWeight++)
{
var boneIndex = br.ReadByte();
if (bReIndexBones)
{
boneIndex = (byte)boneMap[boneIndex];
}
if (v.Weights.Count > iWeight)
{
v.Weights[iWeight].BoneIndex = boneIndex;
}
}
}
}
else
{
if (rigidBone >= numBones || rigidBone < 0)
{
throw new Exception("wtf");
}
v.Weights.Add(new SEModelWeight
{
BoneIndex = rigidBone,
BoneWeight = 1.0f
});
}
}
if (streamData[iStream].HasFlag(DataType.Normal))
{
v.VertexNormal = new Vector3
{
X = br.ReadSingle(),
Y = br.ReadSingle(),
Z = br.ReadSingle(),
};
if (bFlip)
{
v.VertexNormal.X *= -1;
}
}
if (streamData[iStream].HasFlag(DataType.Color))
{
br.Skip(4);
}
if (streamData[iStream].HasFlag(DataType.UVSets1))
{
v.UVSets.Add(new Vector2
{
X = br.ReadSingle(),
Y = br.ReadSingle()
});
if (v.UVSets[0].X > 1.0f)
{
v.UVSets[0].X -= 1.0f;
}
}
if (streamData[iStream].HasFlag(DataType.UVSets2))
{
br.Skip(8);
}
if (streamData[iStream].HasFlag(DataType.UVSets3))
{
br.Skip(8);
}
if (streamData[iStream].HasFlag(DataType.UVSets4))
{
br.Skip(8);
}
if (streamData[iStream].HasFlag(DataType.BasisVectors))
{
br.Skip(24);
}
if (v.Position == null || v.WeightCount == 0)
{
throw new Exception("wtf");
}
mesh.AddVertex(v);
}
}
for (uint iTriangle = 0; iTriangle < numTris; iTriangle++)
{
mesh.AddFace(br.ReadUInt16(), br.ReadUInt16(), br.ReadUInt16());
}
if (lodType == PieceType.SkelMesh && !bUseMatrixPalettes)
{
var boneComboCount = br.ReadUInt32();
for (int iCombo = 0; iCombo < boneComboCount; iCombo++)
{
int m_BoneIndex_Start = br.ReadUInt16();
int m_BoneIndex_End = m_BoneIndex_Start + br.ReadUInt16();
Console.WriteLine($" Weight Combo: {m_BoneIndex_Start} to {m_BoneIndex_End}");
var bones = br.ReadBytes(4);
uint m_iIndexIndex = br.ReadUInt32();
for (int iVertex = m_BoneIndex_Start; iVertex < m_BoneIndex_End; iVertex++)
{
for (int iBone = 0; iBone < 4 && bones[iBone] != 0xFF; iBone++)
{
if (mesh.Verticies[iVertex].Weights.Count <= iBone)
{
break;
}
mesh.Verticies[iVertex].Weights[iBone].BoneIndex = bones[iBone];
}
}
}
}
ltbFile.Meshes.Add(mesh);
br.Skip(br.ReadByte());
}
}
}
#endregion
#region Bones
uint[] boneTree = new uint[numBones];
for (int i = 0; i < numBones; i++)
{
var boneName = br.ReadStringWithUInt16Length();
var boneId = br.ReadByte();
var num2 = br.ReadUInt16();
Matrix4x4 transformMatrix = new Matrix4x4();
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 4; k++)
{
transformMatrix[j, k] = br.ReadSingle();
}
}
boneTree[i] = br.ReadUInt32();
var bone = new SEModelBone
{
BoneName = boneName.Replace('.', '_').Replace('-', '_').Replace(' ', '_'),
GlobalRotation = new Quaternion(transformMatrix),
GlobalPosition = new Vector3(transformMatrix)
};
if (bFlip)
{
bone.GlobalPosition.X *= -1;
bone.GlobalRotation.Y *= -1;
bone.GlobalRotation.Z *= -1;
}
// rotate root bone;
if (boneId == 0)
{
bone.GlobalRotation *= globalRotation;
}
ltbFile.Bones[boneId] = bone;
}
uint[] nSubbone = new uint[numBones];
nSubbone[0] = boneTree[0];
ltbFile.Bones[0].BoneParent = -1;
// Build bone tree
for (byte i = 1; i < numBones; i++)
{
nSubbone[i] = boneTree[i];
for (int j = i - 1; j >= 0; j--)
{
if (nSubbone[j] > 0)
{
nSubbone[j]--;
ltbFile.Bones[i].BoneParent = j;
break;
}
}
}
#endregion
#region Random stuff
Console.WriteLine("\nInternal filenames:");
var childModelCount = br.ReadUInt32();
for (int i = 0; i < childModelCount; i++)
{
Console.WriteLine(br.ReadStringWithUInt16Length());
br.Skip((int)br.ReadUInt32() * 4);
}
br.Skip(4);
#endregion
#region Animations
if (nAnim > 0)
{
var animationCount = br.ReadUInt32();
Console.WriteLine($"\nAnimation count: {animationCount}\n");
for (int i = 0; i < animationCount; i++)
{
var seanim = new SEAnim();
var dim = new Vector3
{
X = br.ReadSingle(),
Y = br.ReadSingle(),
Z = br.ReadSingle(),
};
var animName = br.ReadStringWithUInt16Length();
Console.Write(animName);
var compressionType = (AnimCompressionType)br.ReadUInt32();
var interpolationMS = br.ReadUInt32();
var keyFrameCount = br.ReadUInt32();
Console.WriteLine($" has {keyFrameCount} keyframes");
for (int iKeyFrame = 0; iKeyFrame < keyFrameCount; iKeyFrame++)
{
var time = br.ReadUInt32();
var animString = br.ReadStringWithUInt16Length();
if (!string.IsNullOrEmpty(animString))
{
seanim.AddNoteTrack(animString, iKeyFrame);
}
}
for (byte iBone = 0; iBone < numBones; iBone++)
{
if (compressionType != AnimCompressionType.None)
{
uint pFrames = br.ReadUInt32();
for (int iKeyFrame = 0; iKeyFrame < pFrames; iKeyFrame++)
{
var v = new Vector3(br.ReadInt16() / 16.0, br.ReadInt16() / 16.0, br.ReadInt16() / 16.0);
if (bFlip)
{
v.X *= -1;
}
seanim.AddTranslationKey(ltbFile.Bones[iBone].BoneName, iKeyFrame, v.X, v.Y, v.Z);
}
uint rFrames = br.ReadUInt32();
for (int iKeyFrame = 0; iKeyFrame < rFrames; iKeyFrame++)
{
var q = new Quaternion(br.ReadInt16() / 16.0, -br.ReadInt16() / 16.0, -br.ReadInt16() / 16.0, br.ReadInt16() / 16.0);
if (bFlip)
{
q.Y *= -1;
q.Z *= -1;
}
// rotate root bone;
if (iBone == 0)
{
q *= globalRotation;
}
seanim.AddRotationKey(ltbFile.Bones[iBone].BoneName, iKeyFrame, q.X, q.Y, q.Z, q.W);
}
}
else if (compressionType == AnimCompressionType.None)
{
bool isVertexAnim = br.ReadBoolean();
if (isVertexAnim)
{
throw new Exception("Vertex animation not supported!");
}
else
{
for (int iKeyFrame = 0; iKeyFrame < keyFrameCount; iKeyFrame++)
{
var v = new Vector3(-br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
seanim.AddTranslationKey(ltbFile.Bones[iBone].BoneName, iKeyFrame, v.X, v.Y, v.Z);
}
for (int iKeyFrame = 0; iKeyFrame < keyFrameCount; iKeyFrame++)
{
var q = new Quaternion(br.ReadSingle(), -br.ReadSingle(), -br.ReadSingle(), br.ReadSingle());
// rotate root bone;
if (iBone == 0)
{
q *= globalRotation;
}
seanim.AddRotationKey(ltbFile.Bones[iBone].BoneName, iKeyFrame, q.X, q.Y, q.Z, q.W);
}
}
}
}
ltbFile.Animations.Add(animName + ".seanim", seanim);
}
}
#endregion
return(ltbFile);
}
public async Task LoadFromStream(Stream stream, bool lzma = false)
{
var br = new ExtendedBinaryReader(stream);
// DTX Header
iResType = br.ReadUInt32();
iVersion = br.ReadInt32();
width = br.ReadUInt16();
height = br.ReadUInt16();
nMipmap = br.ReadUInt16();
nSection = br.ReadUInt16();
flags = br.ReadInt32();
userFlags = br.ReadInt32();
extra = br.ReadBytes(12);
cmdStr = br.ReadBytes(128);
if (iResType != 0 || iVersion != -5 || nMipmap == 0)
{
if (lzma)
{
throw new Exception("Unsupported DTX Type");
}
else
{
stream.Position = 0;
var lzmaStream = new LzmaDecodeStream(stream);
var ms = new MemoryStream();
lzmaStream.CopyTo(ms);
await LoadFromStream(ms, true);
return;
}
}
DXTDecoder decoder = null;
if (storeType == 4)
{
decoder = new DXT1Decoder();
}
else if (storeType == 5)
{
decoder = new DXT3Decoder();
}
else if (storeType == 6)
{
decoder = new DXT5Decoder();
}
if (decoder != null)
{
rawBuffer = await decoder.DecodeFrame(stream, width, height);
}
else
{
rawBuffer = br.ReadBytes(width * height * 4);
}
br.Close();
}