public bool RemoveElement(N64DataElement element)
{
if (element is Palette)
{
if (!_palettes.Contains(element))
return false;
_palettes.Remove((Palette)element);
}
else if (element is Texture)
{
if (!_textures.Contains(element))
return false;
_textures.Remove((Texture)element);
}
else if (element is F3DEXCommandCollection)
{
if (!_commandCollections.Contains(element))
return false;
_commandCollections.Remove((F3DEXCommandCollection)element);
}
else if (element is VertexCollection)
{
if (!_vertices.Contains(element))
return false;
_vertices.Remove((VertexCollection)element);
}
else
return false;
return true;
}
public bool AddElement(N64DataElement element)
{
if (element is Palette)
{
if (_palettes.Contains(element))
return false;
_palettes.Add((Palette)element);
_palettes.Sort((e1, e2) => e1.FileOffset.CompareTo(e2.FileOffset));
}
else if (element is Texture)
{
if (_textures.Contains(element))
return false;
_textures.Add((Texture)element);
_textures.Sort((e1, e2) => e1.FileOffset.CompareTo(e2.FileOffset));
}
else if (element is F3DEXCommandCollection)
{
if (_commandCollections.Contains(element))
return false;
_commandCollections.Add((F3DEXCommandCollection)element);
_commandCollections.Sort((e1, e2) => e1.FileOffset.CompareTo(e2.FileOffset));
}
else if (element is VertexCollection)
{
if (_vertices.Contains(element))
return false;
_vertices.Add((VertexCollection)element);
_vertices.Sort((e1, e2) => e1.FileOffset.CompareTo(e2.FileOffset));
}
else
return false;
return true;
}
public bool RemoveElement(N64DataElement element)
{
if (!Elements.Contains(element))
return false;
Elements.Remove(element);
return true;
}
public bool AddElement(N64DataElement element)
{
if (Elements.Contains(element))
return false;
Elements.Add(element);
Elements.Sort((e1, e2) => e1.FileOffset.CompareTo(e2.FileOffset));
return true;
}
public bool AddElement(N64DataElement element, bool overwriteUnknownData = true)
{
if (element.FileOffset < 0)
return false;
int startOffset = element.FileOffset;
int endOffset = startOffset + element.RawDataSize - 1;
//Find if it is inside a currently existing element, or if it can be added freely
int indexToAdd = 0;
bool insideElement = false;
for (; indexToAdd < _elements.Count; indexToAdd++)
{
if (endOffset < _elements[indexToAdd].FileOffset)
{
//Found where to insert the new element
break;
}
else if (_elements[indexToAdd].ContainsOffset(startOffset) ||
_elements[indexToAdd].ContainsOffset(endOffset) ||
element.ContainsOffset(_elements[indexToAdd].FileOffset))
{
insideElement = true;
break;
}
}
//If there were conflicts
if (insideElement)
{
//Determine if we can overwrite unknown data with known data
if (_elements[indexToAdd] is UnknownData && overwriteUnknownData && !((UnknownData)_elements[indexToAdd]).Locked)
{
//Step one: determine how many elements this new one spans
int endingIndex = indexToAdd;
for (; endingIndex < _elements.Count - 1; endingIndex++)
{
//If it doesn't run into this next data element, then it stops before it. Break out of the loop
if (!_elements[endingIndex + 1].ContainsOffset(endOffset) &&
!element.ContainsOffset(_elements[endingIndex + 1].FileOffset))
break;
//Only unlocked unknown data may be split
if (!(_elements[endingIndex + 1] is UnknownData) || ((UnknownData)_elements[indexToAdd]).Locked)
return false;
}
//Step two: determine how to split the start/ends.
bool startUnknownLeftOver = false;
bool endUnknownLeftOver = false;
if (_elements[indexToAdd].ContainsOffset(startOffset) &&
_elements[indexToAdd].FileOffset != startOffset)
startUnknownLeftOver = true;
if (_elements[endingIndex].ContainsOffset(endOffset) &&
_elements[endingIndex].FileOffset + _elements[endingIndex].RawDataSize - 1 != endOffset)
endUnknownLeftOver = true;
if (startUnknownLeftOver)
{
byte[] unknownData = new byte[startOffset - _elements[indexToAdd].FileOffset];
Array.Copy(_elements[indexToAdd].RawData, 0, unknownData, 0, unknownData.Length);
UnknownData newData = new UnknownData(_elements[indexToAdd].FileOffset, unknownData);
_elements.Insert(indexToAdd, newData);
if (UnknownDataAdded != null)
UnknownDataAdded(newData);
indexToAdd++;
endingIndex++;
}
if (endUnknownLeftOver)
{
byte[] unknownData = new byte[_elements[endingIndex].FileOffset + _elements[endingIndex].RawDataSize - (endOffset + 1)];
Array.Copy(_elements[endingIndex].RawData, (endOffset + 1) - _elements[endingIndex].FileOffset, unknownData, 0, unknownData.Length);
UnknownData newData = new UnknownData(endOffset + 1, unknownData);
_elements.Insert(endingIndex + 1, newData);
if (UnknownDataAdded != null)
UnknownDataAdded(newData);
}
//Step 3: Remove the overlapping unknowns, insert the new data
for (int i = 0; i <= endingIndex - indexToAdd; i++)
{
if (UnknownDataRemoved != null)
UnknownDataRemoved((UnknownData)_elements[indexToAdd]);
_elements.RemoveAt(indexToAdd);
}
_elements.Insert(indexToAdd, element);
return true;
}
else
{
return false;
}
}
//Down here, there were no conflicts
_elements.Insert(indexToAdd, element);
return true;
}
public int GetIndexOfElement(N64DataElement element)
{
return _elements.IndexOf(element);
}
public bool HasElement(N64DataElement element)
{
return _elements.Exists(e => e == element);
}
public bool RemoveElement(N64DataElement element)
{
if (!HasElement(element))
return false;
_elements.Remove(element);
return true;
}
public bool RemoveElement(N64DataElement element)
{
if(!_elements.Elements.Contains(element))
return false;
_elements.RemoveElement(element);
foreach (IN64ElementContainer container in _elementContainers)
{
container.RemoveElement(element);
}
_miscElementContainer.RemoveElement(element);
return true;
}
public bool AddElement(N64DataElement element)
{
//Detect if the file size has increased due to this addition
int fileOffsetEnd = element.FileOffset + element.RawDataSize;
if (_lockFileSize && fileOffsetEnd > FileLength)
return false;
if (!_elements.AddElement(element))
return false;
if (fileOffsetEnd > FileLength)
FileLength = fileOffsetEnd;
if(_elementContainers.Count != 0)
{
bool foundContainer = false;
foreach (IN64ElementContainer container in _elementContainers)
{
if(container.AddElement(element))
foundContainer = true;
}
if (!foundContainer)
{
//Toss it into the misc container
_miscElementContainer.AddElement(element);
}
}
return true;
}
