public unsafe IModel LoadModel(GloModelFileBundle gloModelFileBundle)
{
var gloFile = gloModelFileBundle.GloFile;
var textureDirectories = gloModelFileBundle.TextureDirectories;
var fps = 20;
var glo = gloFile.Impl.ReadNew <Glo>(Endianness.LittleEndian);
var textureFilesByName = new Dictionary <string, IFileHierarchyFile>();
foreach (var textureDirectory in textureDirectories)
{
foreach (var textureFile in textureDirectory.Files)
{
textureFilesByName[textureFile.Name.ToLower()] = textureFile;
}
}
/*new MeshCsvWriter().WriteToFile(
* glo, new FinFile(Path.Join(outputDirectory.FullName, "mesh.csv")));
* new FaceCsvWriter().WriteToFile(
* glo, new FinFile(Path.Join(outputDirectory.FullName, "face.csv")));
* new VertexCsvWriter().WriteToFile(
* glo, new FinFile(Path.Join(outputDirectory.FullName, "vertex.csv")));*/
var finModel = new ModelImpl();
var finSkin = finModel.Skin;
var finRootBone = finModel.Skeleton.Root;
var finTextureMap = new LazyDictionary <string, ITexture?>(
textureFilename => {
if (!textureFilesByName.TryGetValue(textureFilename.ToLower(),
out var textureFile))
{
return(null);
}
using var rawTextureImage = FinImage.FromFile(textureFile.Impl);
var textureImageWithAlpha =
GloModelLoader.AddTransparencyToGloImage_(rawTextureImage);
var finTexture = finModel.MaterialManager.CreateTexture(
textureImageWithAlpha);
finTexture.Name = textureFilename;
if (this.mirrorTextures_.Contains(textureFilename))
{
finTexture.WrapModeU = WrapMode.MIRROR_REPEAT;
finTexture.WrapModeV = WrapMode.MIRROR_REPEAT;
}
else
{
finTexture.WrapModeU = WrapMode.REPEAT;
finTexture.WrapModeV = WrapMode.REPEAT;
}
return(finTexture);
});
var withCullingMap =
new LazyDictionary <string, IMaterial>(textureFilename => {
var finTexture = finTextureMap[textureFilename];
if (finTexture == null)
{
return(finModel.MaterialManager.AddStandardMaterial());
}
return(finModel.MaterialManager.AddTextureMaterial(finTexture));
});
var withoutCullingMap = new LazyDictionary <string, IMaterial>(
textureFilename => {
var finTexture = finTextureMap[textureFilename];
IMaterial finMaterial = finTexture == null
? finModel.MaterialManager
.AddStandardMaterial()
: finModel.MaterialManager
.AddTextureMaterial(
finTexture);
finMaterial.CullingMode = CullingMode.SHOW_BOTH;
return(finMaterial);
});
var firstMeshMap = new Dictionary <string, GloMesh>();
// TODO: Consider separating these out as separate models
foreach (var gloObject in glo.Objects)
{
var finObjectRootBone = finRootBone.AddRoot(0, 0, 0);
var meshQueue = new Queue <(GloMesh, IBone)>();
foreach (var topLevelGloMesh in gloObject.Meshes)
{
meshQueue.Enqueue((topLevelGloMesh, finObjectRootBone));
}
List <(IAnimation, int, int)> finAndGloAnimations = new();
foreach (var animSeg in gloObject.AnimSegs)
{
var startFrame = (int)animSeg.StartFrame;
var endFrame = (int)animSeg.EndFrame;
var finAnimation = finModel.AnimationManager.AddAnimation();
finAnimation.Name = animSeg.Name;
finAnimation.FrameCount =
(int)(animSeg.EndFrame - animSeg.StartFrame + 1);
finAnimation.FrameRate = fps * animSeg.Speed;
finAndGloAnimations.Add((finAnimation, startFrame, endFrame));
}
while (meshQueue.Count > 0)
{
var(gloMesh, parentFinBone) = meshQueue.Dequeue();
var name = gloMesh.Name;
GloMesh idealMesh;
if (!firstMeshMap.TryGetValue(name, out idealMesh))
{
firstMeshMap[name] = idealMesh = gloMesh;
}
var position = gloMesh.MoveKeys[0].Xyz;
var rotation = gloMesh.RotateKeys[0];
var quaternion =
new Quaternion(rotation.X, rotation.Y, rotation.Z, rotation.W);
var xyzRadians = QuaternionUtil.ToEulerRadians(quaternion);
var scale = gloMesh.ScaleKeys[0].Scale;
var finBone = parentFinBone
.AddChild(position.X, position.Y, position.Z)
.SetLocalRotationRadians(
xyzRadians.X, xyzRadians.Y, xyzRadians.Z)
.SetLocalScale(scale.X, scale.Y, scale.Z);
finBone.Name = name + "_bone";
var child = gloMesh.Pointers.Child;
if (child != null)
{
meshQueue.Enqueue((child, finBone));
}
var next = gloMesh.Pointers.Next;
if (next != null)
{
meshQueue.Enqueue((next, parentFinBone));
}
foreach (var(finAnimation, startFrame, endFrame) in
finAndGloAnimations)
{
var finBoneTracks = finAnimation.AddBoneTracks(finBone);
long prevTime = -1;
foreach (var moveKey in gloMesh.MoveKeys)
{
Asserts.True(moveKey.Time > prevTime);
prevTime = moveKey.Time;
if (!(moveKey.Time >= startFrame && moveKey.Time <= endFrame))
{
continue;
}
var time = (int)(moveKey.Time - startFrame);
Asserts.True(time >= 0 && time < finAnimation.FrameCount);
var moveValue = moveKey.Xyz;
finBoneTracks.Positions.Set(time, 0, moveValue.X);
finBoneTracks.Positions.Set(time, 1, moveValue.Y);
finBoneTracks.Positions.Set(time, 2, moveValue.Z);
}
prevTime = -1;
foreach (var rotateKey in gloMesh.RotateKeys)
{
Asserts.True(rotateKey.Time > prevTime);
prevTime = rotateKey.Time;
if (!(rotateKey.Time >= startFrame &&
rotateKey.Time <= endFrame))
{
continue;
}
var time = (int)(rotateKey.Time - startFrame);
Asserts.True(time >= 0 && time < finAnimation.FrameCount);
var quaternionKey =
new Quaternion(rotateKey.X, rotateKey.Y, rotateKey.Z,
rotateKey.W);
var xyzRadiansKey = QuaternionUtil.ToEulerRadians(quaternionKey);
finBoneTracks.Rotations.Set(time, 0,
xyzRadiansKey.X);
finBoneTracks.Rotations.Set(time, 1,
xyzRadiansKey.Y);
finBoneTracks.Rotations.Set(time, 2,
xyzRadiansKey.Z);
}
prevTime = -1;
foreach (var scaleKey in gloMesh.ScaleKeys)
{
Asserts.True(scaleKey.Time > prevTime);
prevTime = scaleKey.Time;
if (!(scaleKey.Time >= startFrame && scaleKey.Time <= endFrame))
{
continue;
}
var time = (int)(scaleKey.Time - startFrame);
Asserts.True(time >= 0 && time < finAnimation.FrameCount);
var scaleValue = scaleKey.Scale;
finBoneTracks.Scales.Set(time, 0, scaleValue.X);
finBoneTracks.Scales.Set(time, 1, scaleValue.Y);
finBoneTracks.Scales.Set(time, 2, scaleValue.Z);
}
}
// Anything with these names are debug objects and can be ignored.
if (this.hiddenNames_.Contains(name))
{
continue;
}
var finMesh = finSkin.AddMesh();
finMesh.Name = name;
var gloVertices = idealMesh.Vertices;
string previousTextureName = null;
IMaterial?previousMaterial = null;
foreach (var gloFace in idealMesh.Faces)
{
// TODO: What can we do if texture filename is empty?
var textureFilename = gloFace.TextureFilename;
var gloFaceColor = gloFace.Color;
var finFaceColor = ColorImpl.FromRgbaBytes(
gloFaceColor.R, gloFaceColor.G, gloFaceColor.B, gloFaceColor.A);
var enableBackfaceCulling = (gloFace.Flags & 1 << 2) == 0;
IMaterial?finMaterial;
if (textureFilename == previousTextureName)
{
finMaterial = previousMaterial;
}
else
{
previousTextureName = textureFilename;
finMaterial = enableBackfaceCulling
? withCullingMap[textureFilename]
: withoutCullingMap[textureFilename];
previousMaterial = finMaterial;
}
// Face flag:
// 0: potentially some kind of repeat mode??
var color = (gloFace.Flags & 1 << 6) != 0
? ColorImpl.FromRgbaBytes(255, 0, 0, 255)
: ColorImpl.FromRgbaBytes(0, 255, 0, 255);
var finFaceVertices = new IVertex[3];
for (var v = 0; v < 3; ++v)
{
var gloVertexRef = gloFace.VertexRefs[v];
var gloVertex = gloVertices[gloVertexRef.Index];
var finVertex = finSkin
.AddVertex(gloVertex.X, gloVertex.Y, gloVertex.Z)
.SetUv(gloVertexRef.U, gloVertexRef.V);
//.SetColor(color);
finVertex.SetBoneWeights(finSkin.GetOrCreateBoneWeights(
PreprojectMode.BONE, finBone));
finFaceVertices[v] = finVertex;
}
// TODO: Merge triangles together
var finTriangles = new (IVertex, IVertex, IVertex)[1];
public IModel LoadModel(ModlModelFileBundle modelFileBundle)
{
var flipSign = ModlFlags.FLIP_HORIZONTALLY ? -1 : 1;
var modlFile = modelFileBundle.ModlFile;
using var er = new EndianBinaryReader(modlFile.Impl.OpenRead(),
Endianness.LittleEndian);
var bwModel = modelFileBundle.ModlType switch {
ModlType.BW1 => (IModl)er.ReadNew <Bw1Modl>(),
ModlType.BW2 => er.ReadNew <Bw2Modl>(),
};
var model = new ModelImpl();
var finMesh = model.Skin.AddMesh();
var finBones = new IBone[bwModel.Nodes.Count];
var finBonesByModlNode = new Dictionary <IBwNode, IBone>();
var finBonesByIdentifier = new Dictionary <string, IBone>();
{
var nodeQueue =
new FinTuple2Queue <IBone, ushort>((model.Skeleton.Root, 0));
while (nodeQueue.TryDequeue(out var parentFinBone,
out var modlNodeId))
{
var modlNode = bwModel.Nodes[modlNodeId];
var transform = modlNode.Transform;
var bonePosition = transform.Position;
var modlRotation = transform.Rotation;
var rotation = new Quaternion(
flipSign * modlRotation.X,
modlRotation.Y,
modlRotation.Z,
flipSign * modlRotation.W);
var eulerRadians = QuaternionUtil.ToEulerRadians(rotation);
var finBone =
parentFinBone
.AddChild(flipSign * bonePosition.X, bonePosition.Y,
bonePosition.Z)
.SetLocalRotationRadians(
eulerRadians.X, eulerRadians.Y, eulerRadians.Z);
var identifier = modlNode.GetIdentifier();
finBone.Name = identifier;
finBones[modlNodeId] = finBone;
finBonesByModlNode[modlNode] = finBone;
finBonesByIdentifier[identifier] = finBone;
if (bwModel.CnctParentToChildren.TryGetList(
modlNodeId, out var modlChildIds))
{
nodeQueue.Enqueue(
modlChildIds !.Select(modlChildId => (finBone, modlChildId)));
}
}
foreach (var animFile in modelFileBundle.AnimFiles ??
Array.Empty <IFileHierarchyFile>())
{
var anim = modelFileBundle.ModlType switch {
ModlType.BW1 => (IAnim)animFile.Impl.ReadNew <Bw1Anim>(
Endianness.BigEndian),
ModlType.BW2 => animFile.Impl.ReadNew <Bw2Anim>(
Endianness.BigEndian)
};
var maxFrameCount = -1;
foreach (var animBone in anim.AnimBones)
{
maxFrameCount = (int)Math.Max(maxFrameCount,
Math.Max(
animBone
.PositionKeyframeCount,
animBone
.RotationKeyframeCount));
}
var finAnimation = model.AnimationManager.AddAnimation();
finAnimation.Name = animFile.NameWithoutExtension;
finAnimation.FrameRate = 30;
finAnimation.FrameCount = maxFrameCount;
for (var b = 0; b < anim.AnimBones.Count; ++b)
{
var animBone = anim.AnimBones[b];
var animBoneFrames = anim.AnimBoneFrames[b];
var animNodeIdentifier = animBone.GetIdentifier();
if (!finBonesByIdentifier.TryGetValue(
animNodeIdentifier, out var finBone))
{
// TODO: Gross hack for the vet models, what's the real fix???
if (animNodeIdentifier == Bw1Node.GetIdentifier(33))
{
finBone = finBonesByIdentifier[Bw1Node.GetIdentifier(34)];
}
else if (finBonesByIdentifier.TryGetValue(
animNodeIdentifier + 'X', out var xBone))
{
finBone = xBone;
}
else if (finBonesByIdentifier.TryGetValue(
"BONE_" + animNodeIdentifier,
out var prefixBone))
{
finBone = prefixBone;
}
else if (animNodeIdentifier == "WF_GRUNT_BACKPAC")
{
// TODO: Is this right?????
finBone = finBonesByIdentifier["BONE_BCK_MISC"];
}
else
{
;
}
}
var finBoneTracks = finAnimation.AddBoneTracks(finBone !);
var fbtPositions = finBoneTracks.Positions;
for (var f = 0; f < animBone.PositionKeyframeCount; ++f)
{
var(fPX, fPY, fPZ) = animBoneFrames.PositionFrames[f];
fbtPositions.Set(f, 0, flipSign * fPX);
fbtPositions.Set(f, 1, fPY);
fbtPositions.Set(f, 2, fPZ);
}
var fbtRotations = finBoneTracks.Rotations;
for (var f = 0; f < animBone.RotationKeyframeCount; ++f)
{
var(fRX, fRY, fRZ, frW) = animBoneFrames.RotationFrames[f];
var animationQuaternion =
new Quaternion(flipSign * fRX, fRY, fRZ, flipSign * frW);
var eulerRadians =
QuaternionUtil.ToEulerRadians(animationQuaternion);
fbtRotations.Set(f, 0, eulerRadians.X);
fbtRotations.Set(f, 1, eulerRadians.Y);
fbtRotations.Set(f, 2, eulerRadians.Z);
}
}
}
var textureDictionary = new LazyDictionary <string, ITexture>(
textureName => {
var textureFile =
modlFile.Parent.Files.Single(
file => file.Name.ToLower() == $"{textureName}.png");
var image = FinImage.FromFile(textureFile.Impl);
var finTexture =
model.MaterialManager.CreateTexture(image);
finTexture.Name = textureName;
// TODO: Need to handle wrapping
finTexture.WrapModeU = WrapMode.REPEAT;
finTexture.WrapModeV = WrapMode.REPEAT;
return(finTexture);
});
foreach (var modlNode in bwModel.Nodes)
{
var finMaterials =
modlNode.Materials.Select(modlMaterial => {
var textureName = modlMaterial.Texture1.ToLower();
if (textureName == "")
{
return(null);
}
var finTexture = textureDictionary[textureName];
var finMaterial =
model.MaterialManager
.AddTextureMaterial(finTexture);
return(finMaterial);
})
.ToArray();
foreach (var modlMesh in modlNode.Meshes)
{
var finMaterial = finMaterials[modlMesh.MaterialIndex];
foreach (var triangleStrip in modlMesh.TriangleStrips)
{
var vertices =
new IVertex[triangleStrip.VertexAttributeIndicesList.Count];
for (var i = 0; i < vertices.Length; i++)
{
var vertexAttributeIndices =
triangleStrip.VertexAttributeIndicesList[i];
var position =
modlNode.Positions[vertexAttributeIndices.PositionIndex];
var vertex = vertices[i] = model.Skin.AddVertex(
flipSign * position.X * modlNode.Scale,
position.Y * modlNode.Scale,
position.Z * modlNode.Scale);
if (vertexAttributeIndices.NormalIndex != null)
{
var normal =
modlNode.Normals[
vertexAttributeIndices.NormalIndex.Value];
vertex.SetLocalNormal(flipSign * normal.X, normal.Y,
normal.Z);
}
if (vertexAttributeIndices.NodeIndex != null)
{
var finBone =
finBones[vertexAttributeIndices.NodeIndex.Value];
vertex.SetBoneWeights(
model.Skin
.GetOrCreateBoneWeights(
PreprojectMode.NONE,
new BoneWeight(finBone, null, 1)));
}
else
{
var finBone = finBonesByModlNode[modlNode];
vertex.SetBoneWeights(
model.Skin.GetOrCreateBoneWeights(
PreprojectMode.BONE, finBone));
}
var texCoordIndex0 = vertexAttributeIndices.TexCoordIndices[0];
var texCoordIndex1 = vertexAttributeIndices.TexCoordIndices[1];
if (texCoordIndex1 != null)
{
int texCoordIndex;
if (texCoordIndex0 != null)
{
texCoordIndex =
(texCoordIndex0.Value << 8) | texCoordIndex1.Value;
}
else
{
texCoordIndex = texCoordIndex1.Value;
}
var uv = modlNode.UvMaps[0][texCoordIndex];
vertex.SetUv(uv.U, uv.V);
}
}
var triangleStripPrimitive = finMesh.AddTriangleStrip(vertices);
if (finMaterial != null)
{
triangleStripPrimitive.SetMaterial(finMaterial);
}
}
}
}
}
return(model);
}
}