//Initialize should only be called from parent group during parse.
//Bones need not be imported/exported anyways
protected override bool OnInitialize()
{
MDL0Bone *header = Header;
SetSizeInternal(header->_headerLen);
//Assign true parent using parent header offset
int offset = header->_parentOffset;
//Offsets are always < 0, because parent entries are listed before children
if (offset < 0)
{
//Get address of parent header
MDL0Bone *pHeader = (MDL0Bone *)((byte *)header + offset);
//Search bone list for matching header
foreach (MDL0BoneNode bone in _parent._children)
{
if (pHeader == bone.Header)
{
_parent = bone; break;
} //Assign parent and break
}
}
//Conditional name assignment
if ((_name == null) && (header->_stringOffset != 0))
{
_name = header->ResourceString;
}
//Assign fields
_flags = (BoneFlags)(uint)header->_flags;
_nodeIndex = header->_nodeId;
_boneIndex = header->_index;
_permanentID = header->_index;
_bindState = _frameState = new FrameState(header->_scale, header->_rotation, header->_translation);
(_bindState._quaternion = new Quaternion()).FromEuler(header->_rotation);
_bindMatrix = _frameMatrix = header->_transform;
_inverseBindMatrix = _inverseFrameMatrix = header->_transformInv;
_bMin = header->_boxMin;
_bMax = header->_boxMax;
if (header->_part2Offset != 0)
{
Part2Data * part2 = (Part2Data *)((byte *)header + header->_part2Offset);
ResourceGroup *group = part2->Group;
ResourceEntry *pEntry = &group->_first + 1;
int count = group->_numEntries;
for (int i = 0; i < count; i++)
{
_entries.Add(new String((sbyte *)group + (pEntry++)->_stringOffset));
}
}
//We don't want to process children because not all have been parsed yet.
//Child assigning will be handled by the parent group.
return(false);
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
int count = Children.Count;
VIS0 *header = (VIS0 *)address;
*header = new VIS0(length, _frameCount, count, _unk1, _unk2);
ResourceGroup *group = header->Group;
*group = new ResourceGroup(count);
ResourceEntry *entry = group->First;
VoidPtr dataAddress = group->EndAddress;
foreach (ResourceNode n in Children)
{
entry->_dataOffset = (int)dataAddress - (int)group;
entry++;
int len = n._calcSize;
n.Rebuild(dataAddress, len, force);
dataAddress += len;
}
}
public void PostProcess(VoidPtr userDataAddr, StringTable stringTable)
{
if (Count == 0 || userDataAddr == null)
{
return;
}
UserData *data = (UserData *)userDataAddr;
ResourceGroup *pGroup = data->Group;
ResourceEntry *pEntry = &pGroup->_first;
int count = pGroup->_numEntries;
(*pEntry++) = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
for (int i = 0; i < count; i++)
{
UserDataEntry *entry = (UserDataEntry *)((byte *)pGroup + (pEntry++)->_dataOffset);
if (entry->Type == UserValueType.String && entry->_entryCount > 0)
{
entry->_dataOffset = (int)((VoidPtr)(stringTable[this[i]._entries[0]] + 4) - (VoidPtr)entry);
}
ResourceEntry.Build(pGroup, i + 1, entry, (BRESString *)stringTable[this[i]._name]);
entry->ResourceStringAddress = stringTable[this[i]._name] + 4;
}
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
ResourceGroup *group = (ResourceGroup *)address;
*group = new ResourceGroup(UsedChildren.Count);
int nodeIndex = 0;
ResourceEntry *entry = group->First;
foreach (SCN0EntryNode n in Children)
{
if (n.Name != "<null>")
{
(entry++)->_dataOffset = (int)_dataAddr - (int)group;
n._nodeIndex = nodeIndex++;
n._realIndex = n.Index;
}
else
{
n._nodeIndex = n._realIndex = -1;
}
n.keyframeAddr = keyframeAddress;
n.lightAddr = (RGBAPixel *)lightArrayAddress;
n.Rebuild(_dataAddr, n._calcSize, true);
_dataAddr += n._calcSize;
keyframeAddress += n.keyLen;
lightArrayAddress += n.lightLen;
}
}
protected internal virtual void PostProcess(VoidPtr mdlAddress, VoidPtr dataAddress, StringTable stringTable)
{
ResourceGroup *pGroup = (ResourceGroup *)dataAddress;
ResourceEntry *rEntry = &pGroup->_first;
int index = 1;
(*rEntry++) = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
if (_name == "Bones")
{
foreach (MDL0EntryNode n in _children)
{
PostProcessBone(mdlAddress, n, pGroup, ref index, stringTable);
}
}
else
{
foreach (MDL0EntryNode n in _children)
{
dataAddress = (VoidPtr)pGroup + (rEntry++)->_dataOffset;
ResourceEntry.Build(pGroup, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(mdlAddress, dataAddress, stringTable);
}
}
}
protected internal virtual void PostProcess(VoidPtr mdlAddress, VoidPtr dataAddress, StringTable stringTable)
{
if (dataAddress <= mdlAddress)
{
return;
}
ResourceGroup *pGroup = (ResourceGroup *)dataAddress;
ResourceEntry *rEntry = &pGroup->_first;
int index = 1;
(*rEntry++) = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
if (_name == "Definitions")
{
return;
}
List <ResourceNode> entries = _name == "Bones" ?
((MDL0Node)Parent)._linker.BoneCache.Select(x => x as ResourceNode).ToList() :
Children;
foreach (MDL0EntryNode n in entries)
{
dataAddress = (VoidPtr)pGroup + (rEntry++)->_dataOffset;
ResourceEntry.Build(pGroup, index++, dataAddress, (BRESString *)stringTable[n.Name]);
if (dataAddress > mdlAddress)
{
n.PostProcess(mdlAddress, dataAddress, stringTable);
}
}
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
int count = Children.Count;
ResourceGroup *group;
if (_version == 4)
{
VIS0v4 *header = (VIS0v4 *)address;
* header = new VIS0v4(length, (ushort)_frameCount, (ushort)count, _loop);
group = header->Group;
}
else
{
VIS0v3 *header = (VIS0v3 *)address;
* header = new VIS0v3(length, (ushort)_frameCount, (ushort)count, _loop);
group = header->Group;
}
*group = new ResourceGroup(count);
ResourceEntry *entry = group->First;
VoidPtr dataAddress = group->EndAddress;
foreach (ResourceNode n in Children)
{
(entry++)->_dataOffset = (int)dataAddress - (int)group;
int len = n._calcSize;
n.Rebuild(dataAddress, len, force);
dataAddress += len;
}
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
CHR0 *header = (CHR0 *)address;
*header = new CHR0(length, _numFrames, Children.Count, _unk1, _unk2, _unk3);
ResourceGroup *group = header->Group;
*group = new ResourceGroup(Children.Count);
VoidPtr entryAddress = group->EndAddress;
VoidPtr dataAddress = entryAddress;
foreach (CHR0EntryNode n in Children)
{
dataAddress += n._entryLen;
}
//VoidPtr dataAddr = group->EndAddress;
//CHR0Entry* entry = (CHR0Entry*)group->EndAddress;
ResourceEntry *rEntry = group->First;
foreach (CHR0EntryNode n in Children)
{
rEntry->_dataOffset = (int)entryAddress - (int)group;
rEntry++;
n._dataAddr = dataAddress;
n.Rebuild(entryAddress, n._entryLen, true);
entryAddress += n._entryLen;
dataAddress += n._dataLen;
}
}
//To do
//protected override int OnCalculateSize(bool force)
//{
// int size = CLR0.Size + 0x18 + (Children.Count * 0x10);
// foreach (PAT0EntryNode n in Children)
// size += n.CalculateSize(force);
// return size;
//}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
PAT0 *header = (PAT0 *)dataAddress;
header->ResourceStringAddress = stringTable[Name] + 4;
ResourceGroup *group = header->Group;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (PAT0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
bint *strings = header->StringOffsets1;
for (int i = 0; i < _stringList1.Count; i++)
{
strings[i] = (int)stringTable[_stringList1[i]] + 4 - (int)strings;
}
strings = header->StringOffsets2;
for (int i = 0; i < _stringList2.Count; i++)
{
strings[i] = (int)stringTable[_stringList2[i]] + 4 - (int)strings;
}
}
public ResourceEnumerator(ResourceGroup *group)
{
pGroup = group;
count = pGroup->_numEntries;
index = 0;
pEntry = &pGroup->_first;
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
VIS0v3 *header = (VIS0v3 *)dataAddress;
if (_version == 4)
{
((VIS0v4 *)dataAddress)->ResourceStringAddress = stringTable[Name] + 4;
}
else
{
header->ResourceStringAddress = stringTable[Name] + 4;
}
ResourceGroup *group = header->Group;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (VIS0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
SHP0v3 *header = (SHP0v3 *)dataAddress;
header->ResourceStringAddress = stringTable[Name] + 4;
bint *stringPtr = header->StringEntries;
for (int i = 0; i < header->_numEntries; i++)
{
stringPtr[i] = ((int)stringTable[_strings[i]] + 4) - (int)stringPtr;
}
ResourceGroup *group = header->Group;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (SHP0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
}
public void Write(VoidPtr userDataAddr)
{
if (Count == 0 || userDataAddr == null)
{
return;
}
UserData *data = (UserData *)userDataAddr;
ResourceGroup *pGroup = data->Group;
ResourceEntry *pEntry = &pGroup->_first + 1;
*pGroup = new ResourceGroup(Count);
byte *pData = (byte *)pGroup + pGroup->_totalSize;
int id = 0;
foreach (UserDataClass s in this)
{
(pEntry++)->_dataOffset = (int)pData - (int)pGroup;
UserDataEntry *p = (UserDataEntry *)pData;
*p = new UserDataEntry(
s.DataType != UserValueType.String ? s._entries.Count : s._entries.Count > 0 ? 1 : 0, s._type,
id++);
pData += 0x18;
if (s.DataType != UserValueType.String)
{
for (int i = 0; i < s._entries.Count; i++)
{
if (s.DataType == UserValueType.Float)
{
if (!float.TryParse(s._entries[i], out float x))
{
x = 0;
}
*(bfloat *)pData = x;
pData += 4;
}
else if (s.DataType == UserValueType.Int)
{
if (!int.TryParse(s._entries[i], out int x))
{
x = 0;
}
*(bint *)pData = x;
pData += 4;
}
}
}
p->_totalLen = (int)pData - (int)p;
}
data->_totalLen = (int)pData - (int)userDataAddr;
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
SCN0v4 *header = (SCN0v4 *)dataAddress;
header->ResourceStringAddress = stringTable[Name] + 4;
ResourceGroup *group = header->Group;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
int[] indices = new int[] { -1, -1, -1, -1, -1 };
foreach (SCN0GroupNode g in Children)
{
if (g._name == "LightSet(NW4R)")
{
indices[0] = g.Index;
}
else if (g._name == "AmbLights(NW4R)")
{
indices[1] = g.Index;
}
else if (g._name == "Lights(NW4R)")
{
indices[2] = g.Index;
}
else if (g._name == "Fogs(NW4R)")
{
indices[3] = g.Index;
}
else if (g._name == "Cameras(NW4R)")
{
indices[4] = g.Index;
}
}
for (int i = 0; i < 5; i++)
{
SCN0GroupNode n = indices[i] >= 0 ? Children[indices[i]] as SCN0GroupNode : null;
if (n != null)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(header, dataAddress, stringTable);
}
}
if (_version == 5)
{
_userEntries.PostProcess(((SCN0v5 *)dataAddress)->UserData, stringTable);
}
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
ResourceGroup *group;
if (_version == 5)
{
SCN0v5 *header = (SCN0v5 *)dataAddress;
header->ResourceStringAddress = stringTable[Name] + 4;
if (!String.IsNullOrEmpty(_originalPath))
{
header->OrigPathAddress = stringTable[_originalPath] + 4;
}
group = header->Group;
}
else
{
SCN0v4 *header = (SCN0v4 *)dataAddress;
header->ResourceStringAddress = stringTable[Name] + 4;
if (!String.IsNullOrEmpty(_originalPath))
{
header->OrigPathAddress = stringTable[_originalPath] + 4;
}
group = header->Group;
}
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
int[] indices = new int[] { -1, -1, -1, -1, -1 };
foreach (SCN0GroupNode g in Children)
{
indices[(int)g._type] = g.Index;
}
VoidPtr addr = dataAddress;
for (int i = 0; i < 5; i++)
{
SCN0GroupNode n = indices[i] >= 0 ? Children[indices[i]] as SCN0GroupNode : null;
if (n != null)
{
addr = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, addr, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, addr, stringTable);
}
}
if (_version == 5)
{
_userEntries.PostProcess(((SCN0v5 *)addr)->UserData, stringTable);
}
}
protected internal virtual void PostProcess(VoidPtr mdlAddress, VoidPtr dataAddress, StringTable stringTable)
{
ResourceGroup *pGroup = (ResourceGroup *)dataAddress;
ResourceEntry *rEntry = &pGroup->_first;
int index = 1;
(*rEntry++) = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
if (_name == "Bones")
{
foreach (MDL0EntryNode n in _children)
{
PostProcessBone(mdlAddress, n, pGroup, ref index, stringTable);
}
}
else if (_name == "Textures")
{
//ResourceGroup* dGroup = (ResourceGroup*)((byte*)pGroup + pGroup->_totalSize);
bool hasDec = false;
foreach (MDL0TextureNode n in _children)
{
if (n._texRefs.Count > 0)
{
ResourceEntry.Build(pGroup, index++, (byte *)pGroup + (rEntry++)->_dataOffset, (BRESString *)stringTable[n._name]);
}
if (n._decRefs.Count > 0)
{
hasDec = true;
}
}
if (hasDec)
{
pGroup = (ResourceGroup *)((byte *)pGroup + pGroup->_totalSize);
rEntry = &pGroup->_first;
(*rEntry++) = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
index = 1;
foreach (MDL0TextureNode n in _children)
{
if (n._decRefs.Count > 0)
{
ResourceEntry.Build(pGroup, index++, (byte *)pGroup + (rEntry++)->_dataOffset, (BRESString *)stringTable[n._name]);
}
}
}
}
else
{
foreach (MDL0EntryNode n in _children)
{
dataAddress = (VoidPtr)pGroup + (rEntry++)->_dataOffset;
ResourceEntry.Build(pGroup, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(mdlAddress, dataAddress, stringTable);
}
}
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
PAT0v3 *header = (PAT0v3 *)dataAddress;
if (_version == 4)
{
((PAT0v4 *)dataAddress)->ResourceStringAddress = stringTable[Name] + 4;
}
else
{
header->ResourceStringAddress = stringTable[Name] + 4;
}
ResourceGroup *group = header->Group;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (PAT0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
int i = 0;
bint *strings = header->TexFile;
for (i = 0; i < _textureFiles.Count; i++)
{
if (!String.IsNullOrEmpty(_textureFiles[i]))
{
strings[i] = (int)stringTable[_textureFiles[i]] + 4 - (int)strings;
}
}
strings = header->PltFile;
for (i = 0; i < _paletteFiles.Count; i++)
{
if (!String.IsNullOrEmpty(_paletteFiles[i]))
{
strings[i] = (int)stringTable[_paletteFiles[i]] + 4 - (int)strings;
}
}
}
private static List <Bone> ExtractBones(ResourceGroup *pGroup)
{
int count = pGroup->_numEntries;
List <Bone> list = new List <Bone>(count);
ResourceEntry *pEntry = &pGroup->_first + 1;
for (int i = 0; i < count; i++)
{
list.Add(new Bone((MDL0Bone *)((byte *)pGroup + pEntry->_dataOffset)));
}
return(list);
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
SHP0v3 *header = (SHP0v3 *)dataAddress;
if (_version == 4)
{
((SHP0v4 *)dataAddress)->ResourceStringAddress = stringTable[Name] + 4;
if (!String.IsNullOrEmpty(_originalPath))
{
((SHP0v4 *)dataAddress)->OrigPathAddress = stringTable[_originalPath] + 4;
}
}
else
{
header->ResourceStringAddress = stringTable[Name] + 4;
if (!String.IsNullOrEmpty(_originalPath))
{
header->OrigPathAddress = stringTable[_originalPath] + 4;
}
}
bint *stringPtr = header->StringEntries;
for (int i = 0; i < header->_numEntries; i++)
{
stringPtr[i] = ((int)stringTable[_strings[i]] + 4) - (int)stringPtr;
}
ResourceGroup *group = header->Group;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (SHP0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
if (_version == 4)
{
_userEntries.PostProcess(((SHP0v4 *)dataAddress)->UserData, stringTable);
}
}
public void Write(VoidPtr address)
{
ResourceGroup *group = (ResourceGroup *)address;
group->_numEntries = _entries.Count - 1;
group->_totalSize = (_entries.Count * 0x10) + 8;
ResourceEntry *pEntry = &group->_first;
foreach (BinaryStringEntry e in _entries)
{
*pEntry++ = e.GetEntry();
}
}
protected internal virtual void PostProcess(VoidPtr scn0Address, VoidPtr dataAddress, StringTable stringTable)
{
ResourceGroup *group = (ResourceGroup *)dataAddress;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (SCN0EntryNode n in UsedChildren)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
//n.PostProcess(scn0Address, dataAddress, stringTable);
}
int len = 0;
switch (_type)
{
case GroupType.LightSet:
len = SCN0LightSet.Size;
break;
case GroupType.AmbientLight:
len = SCN0AmbientLight.Size;
break;
case GroupType.Light:
len = SCN0Light.Size;
break;
case GroupType.Fog:
len = SCN0Fog.Size;
break;
case GroupType.Camera:
len = SCN0Camera.Size;
break;
}
bint * hdr = (bint *)scn0Address + 5;
VoidPtr entries = scn0Address + hdr[(int)_type];
foreach (SCN0EntryNode n in Children)
{
n.PostProcess(scn0Address, entries, stringTable);
entries += len;
}
}
public override void OnRebuild(VoidPtr address, int size, bool force)
{
BRESHeader *header = (BRESHeader *)address;
*header = new BRESHeader(size, _numEntries + 1);
ROOTHeader *rootHeader = header->First;
*rootHeader = new ROOTHeader(_rootSize, Children.Count);
ResourceGroup *pMaster = &rootHeader->_master;
ResourceGroup *rGroup = (ResourceGroup *)pMaster->EndAddress;
//Write string table
_stringTable.WriteTable(address + _strOffset);
VoidPtr dataAddr = (VoidPtr)rootHeader + _rootSize;
int gIndex = 1;
foreach (BRESGroupNode g in Children)
{
ResourceEntry.Build(pMaster, gIndex++, rGroup, (BRESString *)_stringTable[g.Name]);
*rGroup = new ResourceGroup(g.Children.Count);
ResourceEntry *nEntry = rGroup->First;
int rIndex = 1;
foreach (BRESEntryNode n in g.Children)
{
//Align data
dataAddr = ((int)dataAddr).Align(n.DataAlign);
ResourceEntry.Build(rGroup, rIndex++, dataAddr, (BRESString *)_stringTable[n.Name]);
//Rebuild entry
int len = n._calcSize;
n.Rebuild(dataAddr, len, force);
n.PostProcess(address, dataAddr, len, _stringTable);
dataAddr += len;
}
g._changed = false;
//Advance to next group
rGroup = (ResourceGroup *)rGroup->EndAddress;
}
_stringTable.Clear();
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
ResourceGroup *group;
if (_version == 4)
{
SHP0v4 *header = (SHP0v4 *)address;
* header = new SHP0v4(_loop, (ushort)(_numFrames), (ushort)_strings.Count);
group = header->Group;
}
else
{
SHP0v3 *header = (SHP0v3 *)address;
* header = new SHP0v3(_loop, (ushort)(_numFrames), (ushort)_strings.Count);
group = header->Group;
}
*group = new ResourceGroup(Children.Count);
VoidPtr entryAddress = group->EndAddress;
VoidPtr dataAddress = entryAddress;
foreach (SHP0EntryNode n in Children)
{
dataAddress += n._entryLen;
}
ResourceEntry *rEntry = group->First;
foreach (SHP0EntryNode n in Children)
{
(rEntry++)->_dataOffset = (int)entryAddress - (int)group;
n._dataAddr = dataAddress;
n.Rebuild(entryAddress, n._entryLen, true);
entryAddress += n._entryLen;
dataAddress += n._dataLen;
}
((SHP0v3 *)address)->_stringListOffset = (int)dataAddress - (int)address;
dataAddress += _strings.Count * 4;
if (_userEntries.Count > 0 && _version == 4)
{
_userEntries.Write(((SHP0v4 *)address)->UserData = dataAddress);
}
}
public void Read(VoidPtr userDataAddr)
{
if (userDataAddr == null)
{
return;
}
UserData * data = (UserData *)userDataAddr;
ResourceGroup *group = data->Group;
ResourceEntry *pEntry = &group->_first + 1;
int count = group->_numEntries;
for (int i = 0; i < count; i++, pEntry++)
{
UserDataEntry *entry = (UserDataEntry *)((VoidPtr)group + pEntry->_dataOffset);
UserDataClass d = new UserDataClass()
{
_name = new string((sbyte *)group + pEntry->_stringOffset)
};
VoidPtr addr = (VoidPtr)entry + entry->_dataOffset;
d._type = entry->Type;
if (d._type != UserValueType.String)
{
for (int x = 0; x < entry->_entryCount; x++)
{
switch (entry->Type)
{
case UserValueType.Float:
d._entries.Add(((float)*(bfloat *)addr).ToString());
addr += 4;
break;
case UserValueType.Int:
d._entries.Add(((int)*(bint *)addr).ToString());
addr += 4;
break;
}
}
}
else
{
d._entries.Add(new string((sbyte *)addr));
}
Add(d);
}
}
protected internal virtual void PostProcess(VoidPtr dataAddress, StringTable stringTable)
{
ResourceGroup *group = (ResourceGroup *)dataAddress;
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (SCN0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
ResourceGroup *group;
if (_version == 5)
{
CHR0v5 *header = (CHR0v5 *)address;
* header = new CHR0v5(_version, length, _numFrames, Children.Count, _loop);
group = header->Group;
}
else
{
CHR0v4_3 *header = (CHR0v4_3 *)address;
* header = new CHR0v4_3(_version, length, _numFrames, Children.Count, _loop);
group = header->Group;
}
*group = new ResourceGroup(Children.Count);
VoidPtr entryAddress = group->EndAddress;
VoidPtr dataAddress = entryAddress;
foreach (CHR0EntryNode n in Children)
{
dataAddress += n._entryLen;
}
ResourceEntry *rEntry = group->First;
foreach (CHR0EntryNode n in Children)
{
(rEntry++)->_dataOffset = (int)entryAddress - (int)group;
n._dataAddr = dataAddress;
n.Rebuild(entryAddress, n._entryLen, true);
entryAddress += n._entryLen;
dataAddress += n._dataLen;
}
if (_userEntries.Count > 0 && _version == 5)
{
CHR0v5 *header = (CHR0v5 *)address;
header->UserData = dataAddress;
_userEntries.Write(dataAddress);
}
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
ResourceGroup *group;
if (_version == 5)
{
SRT0v5 *header = (SRT0v5 *)address;
* header = new SRT0v5((ushort)(_numFrames + ConversionBias), _loop, (ushort)Children.Count, _matrixMode);
group = header->Group;
}
else
{
SRT0v4 *header = (SRT0v4 *)address;
* header = new SRT0v4((ushort)(_numFrames + ConversionBias), _loop, (ushort)Children.Count, _matrixMode);
group = header->Group;
}
*group = new ResourceGroup(Children.Count);
VoidPtr entryAddress = group->EndAddress;
VoidPtr dataAddress = entryAddress;
foreach (SRT0EntryNode n in Children)
{
dataAddress += n._entryLen;
}
ResourceEntry *rEntry = group->First;
foreach (SRT0EntryNode n in Children)
{
(rEntry++)->_dataOffset = (int)entryAddress - (int)group;
n._dataAddr = dataAddress;
n.Rebuild(entryAddress, n._entryLen, true);
entryAddress += n._entryLen;
dataAddress += n._dataLen;
}
if (_userEntries.Count > 0 && _version == 5)
{
SRT0v5 *header = (SRT0v5 *)address;
header->UserData = dataAddress;
_userEntries.Write(dataAddress);
}
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
int count = Children.Count;
int stride = (_numFrames + 1) * 4 * count;
//int data;
CLR0Entry *pEntry = (CLR0Entry *)(address + 0x3C + (count * 0x10));
ABGRPixel *pData = (ABGRPixel *)(((int)pEntry + count * 0x10));
CLR0 *header = (CLR0 *)address;
*header = new CLR0(length, _unk1, _numFrames, count, _unk2);
ResourceGroup *group = header->Group;
*group = new ResourceGroup(count);
ResourceEntry *entry = group->First;
foreach (CLR0EntryNode n in Children)
{
entry->_dataOffset = (int)pEntry - (int)group;
if (n._numEntries == 0)
{
*pEntry = new CLR0Entry(n._flags, (ABGRPixel)n._colorMask, (ABGRPixel)n._solidColor);
}
//*(RGBAPixel*)&data = (RGBAPixel)n._solidColor;
else
{
*pEntry = new CLR0Entry(n._flags, (ABGRPixel)n._colorMask, (int)pData - ((int)pEntry + 12));
}
//data = (int)pData - ((int)pEntry + 12);
entry++;
pEntry++;
foreach (ARGBPixel p in n._colors)
{
*pData++ = (ABGRPixel)p;
}
n._changed = false;
}
}
protected internal override void PostProcess(VoidPtr bresAddress, VoidPtr dataAddress, int dataLength, StringTable stringTable)
{
base.PostProcess(bresAddress, dataAddress, dataLength, stringTable);
ResourceGroup *group;
if (_version == 5)
{
CHR0v5 *header = (CHR0v5 *)dataAddress;
header->ResourceStringAddress = (int)stringTable[Name] + 4;
if (!String.IsNullOrEmpty(_originalPath))
{
header->OrigPathAddress = stringTable[_originalPath] + 4;
}
group = header->Group;
}
else
{
CHR0v4_3 *header = (CHR0v4_3 *)dataAddress;
header->ResourceStringAddress = (int)stringTable[Name] + 4;
if (!String.IsNullOrEmpty(_originalPath))
{
header->OrigPathAddress = stringTable[_originalPath] + 4;
}
group = header->Group;
}
group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
ResourceEntry *rEntry = group->First;
int index = 1;
foreach (CHR0EntryNode n in Children)
{
dataAddress = (VoidPtr)group + (rEntry++)->_dataOffset;
ResourceEntry.Build(group, index++, dataAddress, (BRESString *)stringTable[n.Name]);
n.PostProcess(dataAddress, stringTable);
}
if (_version == 5)
{
_userEntries.PostProcess(((CHR0v5 *)dataAddress)->UserData, stringTable);
}
}
public void UpdateEntries()
{
VoidPtr addr = _workingSource.Address + Header.EntriesChunkOffset;
uint size1 = *(uint *)addr * 8 + 4;
addr += size1;
uint size2 = *(uint *)addr + 4;
addr += size2;
for (int i = 0; i < Header.EntryCount; i++)
{
if (ResourceEntries[i] == null)
{
//ResourceEntry* entry = (ResourceEntry*)addr;
//*entry = new ResourceEntry
//{
// offInPack = 0xBBBBBBBB,
// nameOffsetEtc = 0xBBBBBBBB,
// cmpSize = 0xBBBBBBBB,
// decSize = 0xBBBBBBBB,
// timestamp = 0xBBBBBBBB,
// flags = 0xBBBBBBBB
//};
addr += 0x18;
}
else
{
ResourceEntry *entry = (ResourceEntry *)addr;
*entry = new ResourceEntry
{
offInPack = ResourceEntries[i].OffInPack,
nameOffsetEtc = ResourceEntries[i].NameOffsetEtc,
cmpSize = ResourceEntries[i].CmpSize,
decSize = ResourceEntries[i].DecSize,
timestamp = ResourceEntries[i].Timestamp,
flags = ResourceEntries[i].Flags
};
addr += 0x18;
}
}
}
