public Kh2Map(GraphicsDevice graphics, IDataContent content, string path)
{
_graphics = graphics;
var binarc = content.FileOpen(path).Using(Bar.Read);
_skybox0MeshGroup = FromMdlx(graphics, binarc, "SK0") ?? Empty;
_skybox1MeshGroup = FromMdlx(graphics, binarc, "SK1") ?? Empty;
_mapMeshGroup = FromMdlx(graphics, binarc, "MAP") ?? Empty;
_bobEntities = binarc.ForEntry("out", Bar.EntryType.BgObjPlacement, BobDescriptor.Read)?
.Select(x => new BobEntity(x))?.ToList() ?? new List <BobEntity>();
var bobModels = binarc.ForEntries("BOB", Bar.EntryType.Model, Mdlx.Read).ToList();
var bobTextures = binarc.ForEntries("BOB", Bar.EntryType.ModelTexture, ModelTexture.Read).ToList();
_bobModels = new List <MeshGroup>(bobModels.Count);
for (var i = 0; i < bobModels.Count; i++)
{
_bobModels.Add(new MeshGroup
{
MeshDescriptors = MeshLoader.FromKH2(bobModels[i]).MeshDescriptors,
Textures = bobTextures[i].LoadTextures(graphics).ToArray()
});
}
}
private void LoadMap(int worldIndex, int placeIndex)
{
Log.Info($"Map={worldIndex},{placeIndex}");
var fileName = Kernel.GetMapFileName(worldIndex, placeIndex);
var entries = _dataContent.FileOpen(fileName).Using(Bar.Read);
AddMesh(FromMdlx(_graphics.GraphicsDevice, entries, "SK0"));
AddMesh(FromMdlx(_graphics.GraphicsDevice, entries, "SK1"));
AddMesh(FromMdlx(_graphics.GraphicsDevice, entries, "MAP"));
_bobEntities = entries.ForEntry("out", Bar.EntryType.BgObjPlacement, BobDescriptor.Read)?
.Select(x => new BobEntity(x))?.ToList() ?? new List <BobEntity>();
var bobModels = entries.ForEntries("BOB", Bar.EntryType.Model, Mdlx.Read).ToList();
var bobTextures = entries.ForEntries("BOB", Bar.EntryType.ModelTexture, ModelTexture.Read).ToList();
for (var i = 0; i < bobModels.Count; i++)
{
_bobModels.Add(new MeshGroup
{
MeshDescriptors = MeshLoader.FromKH2(bobModels[i]).MeshDescriptors,
Textures = bobTextures[i].LoadTextures(_graphics.GraphicsDevice).ToArray()
});
}
}
private static MeshGroup FromMdlx(
GraphicsDevice graphics, ArchiveManager archiveManager, string modelName, string textureName)
{
Log.Info($"Load model={modelName} texture={textureName}");
return(MeshLoader.FromKH2(graphics,
archiveManager.Get <Mdlx>(modelName),
archiveManager.Get <ModelTexture>(textureName)));
}
public void Invalidate()
{
MeshGroup = new MeshGroup
{
MeshDescriptors = MeshLoader.FromKH2(_model).MeshDescriptors,
Textures = _kingdomTextures
};
}
public MeshGroup this[int objId]
{
get
{
if (_meshGroups.TryGetValue(objId, out var meshGroup))
{
return(meshGroup);
}
var objEntryName = _objEntryLookupReversed[objId];
var modelPath = Path.Combine(_objPath, objEntryName);
var modelFileName = modelPath + ".mdlx";
if (File.Exists(modelFileName))
{
var mdlxEntries = File.OpenRead(modelFileName).Using(Bar.Read);
var modelEntry = mdlxEntries.FirstOrDefault(x => x.Type == Bar.EntryType.Model);
if (modelEntry != null)
{
var model = Mdlx.Read(modelEntry.Stream);
ModelTexture textures = null;
var textureEntry = mdlxEntries.FirstOrDefault(x => x.Type == Bar.EntryType.ModelTexture);
if (textureEntry != null)
{
textures = ModelTexture.Read(textureEntry.Stream);
}
var modelMotion = MeshLoader.FromKH2(model);
modelMotion.ApplyMotion(modelMotion.InitialPose);
meshGroup = new MeshGroup
{
MeshDescriptors = modelMotion.MeshDescriptors,
Textures = textures == null ? new IKingdomTexture[0] : textures.LoadTextures(_graphics).ToArray()
};
}
else
{
meshGroup = EmptyMeshGroup;
}
}
else
{
meshGroup = EmptyMeshGroup;
}
_meshGroups[objId] = meshGroup;
return(meshGroup);
}
}
public void LoadMesh(GraphicsDevice graphics)
{
var objEntry = Kernel.ObjEntries.FirstOrDefault(x => x.ObjectId == ObjectId);
if (objEntry == null)
{
Log.Warn("Object ID {0} not found.", ObjectId);
return;
}
IsPlayer = objEntry.ObjectType == Objentry.Type.PLAYER;
var modelName = $"obj/{objEntry.ModelName}.mdlx";
using var stream = Kernel.DataContent.FileOpen(modelName);
var entries = Bar.Read(stream);
_model = entries.ForEntry(x => x.Type == Bar.EntryType.Model, Mdlx.Read);
Model = MeshLoader.FromKH2(_model);
var texture = entries.ForEntry("tim_", Bar.EntryType.ModelTexture, ModelTexture.Read);
Textures = texture.LoadTextures(graphics).ToArray();
ObjectCollisions = entries.ForEntry(x => x.Type == Bar.EntryType.ModelCollision && x.Stream.Length > 0,
ObjectCollision.Read) ?? new List <ObjectCollision>();
try
{
var msetName = $"obj/{objEntry.AnimationName}";
if (Kernel.DataContent.FileExists(msetName))
{
var msetEntries = Kernel.DataContent.FileOpen(msetName).Using(Bar.Read);
Motion = new Kh2MotionEngine(msetEntries)
{
CurrentAnimationIndex = 0
};
}
else
{
Motion = new Kh2MotionEngine();
Log.Warn("MSET {0} does not exist", objEntry.AnimationName);
}
}
catch (System.NotImplementedException)
{
Motion = null;
}
}
public void LoadMesh(GraphicsDevice graphics)
{
var objEntry = Kernel.ObjEntries.FirstOrDefault(x => x.ObjectId == ObjectId);
if (objEntry == null)
{
Log.Warn($"Object ID {ObjectId} not found.");
return;
}
var fileName = $"obj/{objEntry.ModelName}.mdlx";
using var stream = Kernel.DataContent.FileOpen(fileName);
var entries = Bar.Read(stream);
var model = entries.ForEntry(x => x.Type == Bar.EntryType.Model, Mdlx.Read);
var texture = entries.ForEntry("tim_", Bar.EntryType.ModelTexture, ModelTexture.Read);
Mesh = MeshLoader.FromKH2(graphics, model, texture);
}
private static MeshGroup FromMdlx(GraphicsDevice graphics, IEnumerable <Bar.Entry> entries, string name)
{
var model = entries.ForEntry(name, Bar.EntryType.Model, Mdlx.Read);
if (model == null)
{
return(null);
}
var textures = entries.ForEntry(name, Bar.EntryType.ModelTexture, ModelTexture.Read);
if (model == null)
{
return(null);
}
return(new MeshGroup
{
MeshDescriptors = MeshLoader.FromKH2(model).MeshDescriptors,
Textures = textures.LoadTextures(graphics).ToArray()
});
}
public MeshGroup this[int objId]
{
get
{
if (_meshGroups.TryGetValue(objId, out var meshGroup))
{
return(meshGroup);
}
var objEntryName = _objEntryLookupReversed[objId];
var modelPath = Path.Combine(_objPath, objEntryName);
var modelFileName = modelPath + ".mdlx";
if (File.Exists(modelFileName))
{
var mdlxEntries = File.OpenRead(modelFileName).Using(Bar.Read);
var modelEntry = mdlxEntries.FirstOrDefault(x => x.Type == Bar.EntryType.Model);
if (modelEntry != null)
{
var model = Mdlx.Read(modelEntry.Stream);
var textures = ModelTexture.Read(mdlxEntries.First(x => x.Type == Bar.EntryType.ModelTexture).Stream);
meshGroup = MeshLoader.FromKH2(_graphics, model, textures);
}
else
{
meshGroup = EmptyMeshGroup;
}
}
else
{
meshGroup = EmptyMeshGroup;
}
_meshGroups[objId] = meshGroup;
return(meshGroup);
}
}
private void LoadMap(int worldIndex, int placeIndex)
{
Log.Info($"Map={worldIndex},{placeIndex}");
string fileName;
if (_kernel.IsReMix)
{
fileName = $"map/{Constants.WorldIds[worldIndex]}{placeIndex:D02}.map";
}
else
{
fileName = $"map/{_kernel.Language}/{Constants.WorldIds[worldIndex]}{placeIndex:D02}.map";
}
var entries = _dataContent.FileOpen(fileName).Using(Bar.Read);
AddMesh(FromMdlx(_graphics.GraphicsDevice, entries, "SK0"));
AddMesh(FromMdlx(_graphics.GraphicsDevice, entries, "SK1"));
AddMesh(FromMdlx(_graphics.GraphicsDevice, entries, "MAP"));
_bobEntities = entries.ForEntry("out", Bar.EntryType.BobDescriptor, BobDescriptor.Read)?
.Select(x => new BobEntity(x))?.ToList() ?? new List <BobEntity>();
var bobModels = entries.ForEntries("BOB", Bar.EntryType.Model, Mdlx.Read).ToList();
var bobTextures = entries.ForEntries("BOB", Bar.EntryType.ModelTexture, ModelTexture.Read).ToList();
for (var i = 0; i < bobModels.Count; i++)
{
var bobMesh = MeshLoader.FromKH2(_graphics.GraphicsDevice, bobModels[i], bobTextures[i]);
if (bobMesh != null)
{
_bobModels.Add(bobMesh);
}
}
}
private static MeshGroup FromMdlx(GraphicsDevice graphics, IEnumerable <Bar.Entry> entries, string name)
{
return(MeshLoader.FromKH2(graphics,
entries.ForEntry(name, Bar.EntryType.Model, Mdlx.Read),
entries.ForEntry(name, Bar.EntryType.ModelTexture, ModelTexture.Read)));
}
public void Invalidate()
{
MeshGroup = MeshLoader.FromKH2(_model);
MeshGroup.Textures = _kingdomTextures;
}
