private static unsafe Chunk HandleMver(ChunkHeader* header)
{
var mver = new MverChunk(header);
if (mver.Version != Version)
throw new WmoVersionException(Version, mver.Version);
return mver;
}
internal unsafe StringReferenceChunk(ChunkHeader* header)
: base(header)
{
var begin = (byte*)ChunkHeader.ChunkBegin(header);
var end = begin + header->Size;
var curBegin = begin;
var cur = begin;
Strings = new List<StringReference>();
while(cur < end)
{
if (*cur == 0)
{
var length = (int)(cur - curBegin);
if (length > 0)
{
Strings.Add(new StringReference
{
String = Marshal.PtrToStringAnsi((IntPtr)curBegin, length),
Offset = (int)(curBegin - begin)
});
}
curBegin = cur + 1;
}
cur++;
}
}
internal unsafe MohdChunk(ChunkHeader* header)
: base(header)
{
var mohd = (Mohd*)(header + 1);
Bounds = mohd->bounds;
GroupCount = mohd->groupCount;
DoodadCount = mohd->doodadCount;
}
internal unsafe MapChunk(ChunkHeader* header)
: base(header)
{
header->ValidateMagic("MCNK");
var cur = (byte*)header + sizeof(ChunkHeader);
ParseMcnkHeader(cur);
Chunks = ChunkCollector.CreateChunks(cur + sizeof(McnkHeader), cur + header->Size, CreateChunks);
}
internal unsafe OffsetChunk(ChunkHeader* header)
: base(header)
{
Offsets = new int[header->Size/sizeof(int)];
var cur = (int*)ChunkHeader.ChunkBegin(header);
for (var i = 0; i < Offsets.Length; i++)
{
Offsets[i] = *cur++;
}
}
internal unsafe MliqChunk(ChunkHeader* header)
: base(header)
{
var mliq = (Mliq*)ChunkHeader.ChunkBegin(header);
Position = mliq->position;
var entries = (HeightMapEntry*)(mliq + 1);
var columns = mliq->vertexColumns;
var rows = mliq->vertexRows;
ParseHeightMap(entries, columns, rows);
var flags = (byte*)(entries + columns*rows);
ParseExistsTable(flags, columns - 1, rows - 1);
}
internal unsafe McvtChunk(ChunkHeader* header)
: base(header)
{
header->ValidateMagic("MCVT");
HeightMap = new float[NonDetailVertices, NonDetailVertices];
var values = (float*)((byte*)header + sizeof(ChunkHeader));
for (int r = 0; r < NonDetailVertices; r++)
{
for (int c = 0; c < NonDetailVertices; c++)
{
HeightMap[r, c] = values[r * ColumnsPerRow + c];
}
}
}
private unsafe Chunk CreateChunk(ChunkHeader* header)
{
switch (header->Magic)
{
case "MPHD":
var mphd = new MphdChunk(header);
Flags = mphd.Flags;
return mphd;
case "MAIN":
_main = new MainChunk(header);
return _main;
case "MWMO":
return new StringReferenceChunk(header);
case "MODF":
return new ModfChunk(header);
default:
return new Chunk(header);
}
}
private unsafe Chunk CreateChunks(ChunkHeader* header)
{
switch (header->Magic)
{
case "MCVT":
var mcvt = new McvtChunk(header);
HeightMap = mcvt.HeightMap;
_bounds.Maximum.Z += HeightMap.Cast<float>().Max();
return mcvt;
case "MCRD":
var mcrd = new OffsetChunk(header);
DoodadReferences = mcrd.Offsets;
return mcrd;
case "MCRW":
var mcrw = new OffsetChunk(header);
WmoReferences = mcrw.Offsets;
return mcrw;
default:
return new Chunk(header);
}
}
internal unsafe ModfChunk(ChunkHeader* header) : base(header)
{
var begin = (byte*)ChunkHeader.ChunkBegin(header);
var end = begin + header->Size;
Definitions = new List<IModelDefinition>(header->Size / sizeof(ModfEntry));
for (var entry = (ModfEntry*)begin; entry < end; entry++)
{
Definitions.Add(new RootModelDefinition
{
Id = entry->uniqueId,
ReferenceIndex = entry->mwidEntry,
Position = new Vector3(
MapOriginOffset - entry->position.Z,
MapOriginOffset - entry->position.X,
entry->position.Y
),
Rotation = entry->rotation,
Scale = 1.0f,
ExtraDoodadSetIndex = entry->doodadSet,
Flags = entry->flags
});
}
}
internal unsafe ModelDefinitionChunk(ChunkHeader* header)
: base(header)
{
}
internal unsafe ModdChunk(ChunkHeader* header)
: base(header)
{
ParseDefinitions((Modd*)ChunkHeader.ChunkBegin(header), header->Size/sizeof(Modd));
}
private unsafe Chunk HandleModd(ChunkHeader* header)
{
var modd = new ModdChunk(header);
DoodadDefinitions = modd.Definitions;
return modd;
}
internal unsafe ModsChunk(ChunkHeader* header)
: base(header)
{
ParseSets((Mods*)ChunkHeader.ChunkBegin(header), header->Size / sizeof(Mods));
}
internal unsafe Chunk(ChunkHeader* header)
{
Magic = header->Magic;
Size = header->Size;
}
private unsafe Chunk HandleMh2o(ChunkHeader* header)
{
_mh2o = new Mh2oChunk(header);
return _mh2o;
}
private unsafe Chunk HandleModf(ChunkHeader* header)
{
_modf = new ModfChunk(header);
WmoDefinitions = _modf.Definitions;
return _modf;
}
private unsafe Chunk HandleMcnk(ChunkHeader* header)
{
var chunk = new MapChunk(header);
MapChunks.Add(chunk);
return chunk;
}
private unsafe Chunk CreateChunk(ChunkHeader* header)
{
switch (header->Magic)
{
case "MVER":
return HandleMver(header);
case "MH2O":
return HandleMh2o(header);
case "MCNK":
return HandleMcnk(header);
default:
return new Chunk(header);
}
}
private unsafe Chunk CreateChunk(ChunkHeader* header)
{
switch (header->Magic)
{
case "MVER":
return HandleMver(header);
case "MOHD":
return _mohd = new MohdChunk(header);
case "MODS":
return HandleMods(header);
case "MODN":
return HandleModn(header);
case "MODD":
return HandleModd(header);
default:
return new Chunk(header);
}
}
private unsafe Chunk HandleModn(ChunkHeader* header)
{
var modn = new StringReferenceChunk(header);
DoodadReferences = modn.Strings;
return modn;
}
private unsafe Chunk HandleMods(ChunkHeader* header)
{
var mods = new ModsChunk(header);
DoodadSets = mods.DoodadSets;
return mods;
}
private unsafe Chunk ExtendChunk(ChunkHeader* header)
{
if (header->Size == 0) return null;
switch (header->Magic)
{
case "MVER":
HandleMver(header);
return null;
case "MH2O":
return null;
case "MCNK":
MapChunks[_mcnkCounter++].ParseOptionalData(header);
return null;
case "MWID":
return new OffsetChunk(header);
case "MMID":
return new OffsetChunk(header);
case "MMDX":
return HandleMmdx(header);
case "MWMO":
return HandleMwmo(header);
case "MDDF":
return HandleMddf(header);
case "MODF":
return HandleModf(header);
default:
return new Chunk(header);
}
}
internal unsafe MainChunk(ChunkHeader* header)
: base(header)
{
ParseFlags((SMAreaInfo*)ChunkHeader.ChunkBegin(header));
}
private unsafe Chunk HandleMddf(ChunkHeader* header)
{
_mddf = new MddfChunk(header);
DoodadDefinitions = _mddf.Definitions;
return _mddf;
}
internal unsafe MovtChunk(ChunkHeader* header)
: base(header)
{
ParseVertices((Vector3*)ChunkHeader.ChunkBegin(header), header->Size/sizeof(Vector3));
}
private unsafe Chunk HandleMmdx(ChunkHeader* header)
{
_mmdx = new StringReferenceChunk(header);
DoodadReferences = _mmdx.Strings;
return _mmdx;
}
internal unsafe MverChunk(ChunkHeader* header)
: base(header)
{
Version = *(int*)(header + 1);
}
private unsafe Chunk HandleMwmo(ChunkHeader* header)
{
_mwmo = new StringReferenceChunk(header);
WmoReferences = _mwmo.Strings;
return _mwmo;
}
private unsafe Chunk HandleMogp(ChunkHeader* header)
{
_mogp = new MogpChunk(header);
TriangleFlags = _mogp.TriangleFlags;
Vertices = _mogp.Vertices;
Triangles = _mogp.Triangles;
Liquid = _mogp.Liquid;
return _mogp;
}
