public ProcessingAnimation(string name, int step, int length, List <List <ProcessingFrame> > frameArray, TimelineInfoMap infoProvider)
{
Name = name;
Step = step;
Length = length;
FrameArray = frameArray;
InfoProvider = infoProvider;
}
/* makes it such that each sprite and bones id in the scml matches those given by the id provider
* while also ensuring that the parent ids are also kept accurate
* this allows for consistent ids that are 0-indexed and without any missing integers */
private void IdRename(XmlElement animation, TimelineInfoMap infoProvider)
{
/* when renaming parent, the id always refers to the id for the bone refs */
XmlElement mainline = GetFirstChildByName(animation, "mainline");
foreach (XmlNode keyNode in mainline.ChildNodes)
{
if (keyNode is XmlElement && keyNode.Name.Equals("key"))
{
Dictionary <int, int> symbolIdToTimelineMap = new Dictionary <int, int>();
foreach (XmlNode refNode in keyNode.ChildNodes)
{
if (refNode is XmlElement && refNode.Name.Equals("bone_ref"))
{
int id = int.Parse(((XmlElement)refNode).GetAttribute("id"));
int timeline = int.Parse(((XmlElement)refNode).GetAttribute("timeline"));
symbolIdToTimelineMap.Add(id, timeline);
}
}
foreach (XmlNode refNode in keyNode.ChildNodes)
{
if (refNode is XmlElement)
{
XmlElement refElement = (XmlElement)refNode;
int timeline = int.Parse(refElement.GetAttribute("timeline"));
refElement.SetAttribute("id", infoProvider.GetId(timeline).ToString());
if (refElement.HasAttribute("parent"))
{
int parent = int.Parse(refElement.GetAttribute("parent"));
refElement.SetAttribute("parent", infoProvider.GetId(symbolIdToTimelineMap[parent]).ToString());
}
}
}
}
}
}
private ProcessingAnimation ParseAnimation(XmlDocument scml, XmlElement animation)
{
string name = animation.GetAttribute("name");
int length = int.Parse(animation.GetAttribute("length"));
int interval = int.Parse(animation.GetAttribute("interval"));
TimelineInfoMap infoProvider = new TimelineInfoMap(scml, name);
/* rename the ids to match timelines in "id" and "parent" */
IdRename(animation, infoProvider);
/* build the frame array - description is in Alternate.Animation */
List <List <ProcessingFrame> > frameArray = new List <List <ProcessingFrame> >();
/* count of frames to know how large the frame array should be */
int numberOfFrames = length / interval + 1;
/* for each sprite and bone id a list of frames is created */
for (int i = 0; i < infoProvider.Size(); i++)
{
List <ProcessingFrame> frames = new List <ProcessingFrame>();
for (int j = 0; j < numberOfFrames; j++)
{
/* start out with a completely empty frame array so it can later be populated
* with the existing data and then finally with the interpolated data */
frames.Add(null);
}
frameArray.Add(frames);
}
/* error checking to see if the animation doesn't have every frame snapped to an interval
* because ONI expects every frame to have a consistent interval so if the frames aren't
* snapped they will be placed wrong */
var hasBrokenSnapping = false;
var brokenAnims = new HashSet <string>();
/* error checking if user has accidentally used pivots in timeline rather than setting pivot on original sprite */
var hasPivotsSpecifiedInTimeline = false;
var pivotAnims = new HashSet <string>();
/* read all the data from mainline
* oddly it is not needed to read which timeline key frame is associated
* with each mainline key frame since the timline key frames contain timing
* information which can be used to exactly place them in the array since
* we force snapping to intervals for ONI animations */
XmlElement mainline = GetFirstChildByName(animation, "mainline");
foreach (XmlNode keyNode in mainline.ChildNodes)
{
if (keyNode is XmlElement && keyNode.Name.Equals("key"))
{
int time = 0;
XmlElement keyElement = (XmlElement)keyNode;
if (keyElement.HasAttribute("time"))
{
time = int.Parse(keyElement.GetAttribute("time"));
}
if (time % interval != 0)
{
Logger.Warn(
$"While parsing animation \"{name}\", found broken snapping in the mainline: it is time {time} ms that is not a multiple of snapping interval {interval} ms.");
hasBrokenSnapping = true;
brokenAnims.Add(name);
}
/* scale the time by the interval between frames to figure out which
* frame index in the array this goes to */
int frameIndex = time / interval;
foreach (XmlNode refNode in keyNode.ChildNodes)
{
if (refNode is XmlElement &&
(refNode.Name.Equals("object_ref") || refNode.Name.Equals("bone_ref")))
{
XmlElement refElement = (XmlElement)refNode;
/* the call to IdRename ensures that the ids on each ref now match the actual index in the array */
int id = int.Parse(refElement.GetAttribute("id"));
int zIndex = 0;
if (refElement.HasAttribute("z_index")) /* will always be true for sprites never true for bones */
{
zIndex = int.Parse(refElement.GetAttribute("z_index"));
}
int parent = -1;
if (refElement.HasAttribute("parent")) /* optional for both sprites and bones */
{
parent = int.Parse(refElement.GetAttribute("parent"));
}
/* set this frame to contain the data stored in the mainline */
frameArray[id][frameIndex] = new ProcessingFrame(parent, zIndex);
}
}
}
}
/* read all the data from each timeline and use it to further populate the data of each frame */
foreach (XmlNode timelineNode in animation.ChildNodes)
{
if (timelineNode is XmlElement && timelineNode.Name.Equals("timeline"))
{
XmlElement timelineElement = (XmlElement)timelineNode;
int timeline = int.Parse(timelineElement.GetAttribute("id"));
int timelineIndex = infoProvider.GetId(timeline);
float x = 0;
float y = 0;
float angle = 0;
foreach (XmlNode keyNode in timelineNode.ChildNodes)
{
if (keyNode is XmlElement && keyNode.Name.Equals("key"))
{
XmlElement keyElement = (XmlElement)keyNode;
int time = 0;
if (keyElement.HasAttribute("time"))
{
time = int.Parse(keyElement.GetAttribute("time"));
}
if (time % interval != 0)
{
Logger.Warn(
$"While parsing animation \"{name}\", found broken snapping at timeline {timeline}: it is time {time} ms that is not a multiple of snapping interval {interval} ms.");
hasBrokenSnapping = true;
brokenAnims.Add(name);
}
int frameIndex = time / interval;
XmlElement child = GetFirstChildByName(keyElement, "object");
if (child == null)
{
child = GetFirstChildByName(keyElement, "bone");
}
if (child == null)
{
throw new ArgumentException("Found timeline key without child object or bone");
}
int folder = -1;
if (child.HasAttribute("folder"))
{
folder = int.Parse(child.GetAttribute("folder"));
}
int file = -1;
if (child.HasAttribute("file"))
{
file = int.Parse(child.GetAttribute("file"));
}
if (child.HasAttribute("x"))
{
x = float.Parse(child.GetAttribute("x"));
}
if (child.HasAttribute("y"))
{
y = float.Parse(child.GetAttribute("y"));
}
if (child.HasAttribute("angle"))
{
angle = float.Parse(child.GetAttribute("angle"));
}
float scaleX = 1.0f;
if (child.HasAttribute("scale_x"))
{
scaleX = float.Parse(child.GetAttribute("scale_x"));
}
float scaleY = 1.0f;
if (child.HasAttribute("scale_y"))
{
scaleY = float.Parse(child.GetAttribute("scale_y"));
}
frameArray[timelineIndex][frameIndex].Populate(folder, file, x, y, angle, scaleX, scaleY);
if (child.HasAttribute("pivot_x") || child.HasAttribute("pivot_y"))
{
hasPivotsSpecifiedInTimeline = true;
pivotAnims.Add(name);
}
}
}
}
}
if (hasBrokenSnapping)
{
var anims = brokenAnims.ToList().Join();
throw new ProjectParseException(
$"SCML format exception: The timelines in anims {anims} had frames at times not snapped to the running interval {interval} ms. Aborting read.");
}
if (hasPivotsSpecifiedInTimeline)
{
var anims = pivotAnims.ToList().Join();
throw new ProjectParseException(
$"SCML format exception: There were pivot points specified in timelines rather than only on the sprites in anims {anims}. Aborting read.");
}
/* determine which frames need to be interpolated by checking which frames are key frames in the mainline */
List <bool> keyFrames = new List <bool>();
for (int i = 0; i < numberOfFrames; i++)
{
keyFrames.Add(false);
}
foreach (XmlNode keyNode in mainline.ChildNodes)
{
if (keyNode is XmlElement && keyNode.Name.Equals("key"))
{
int time = 0;
XmlElement keyElement = (XmlElement)keyNode;
if (keyElement.HasAttribute("time"))
{
time = int.Parse(keyElement.GetAttribute("time"));
}
/* scale the time by the interval between frames to figure out which
* frame index in the array this goes to */
int frameIndex = time / interval;
/* now we know this particular time step is a key frame in the mainline */
keyFrames[frameIndex] = true;
}
}
/* create an additional array that indicates presence of each timeline on a per-frame basis */
List <List <bool> > presenceArray = new List <List <bool> >();
for (int i = 0; i < infoProvider.Size(); i++)
{
List <bool> presences = new List <bool>();
for (int j = 0; j < numberOfFrames; j++)
{
/* start out with a completely empty presence array so it can later be populated
* with the existing data and then finally with the interpolated data */
presences.Add(false);
}
presenceArray.Add(presences);
}
for (int i = 0; i < infoProvider.Size(); i++)
{
bool currentPresence = false;
for (int j = 0; j < numberOfFrames; j++)
{
/* if this frame is a key frame then update the current presence based on if there
* is a frame populated at this location */
if (keyFrames[j])
{
currentPresence = (frameArray[i][j] != null);
}
presenceArray[i][j] = currentPresence;
}
for (int j = 0; j < numberOfFrames; j++)
{
/* if this frame is a key frame then update the current presence based on if there
* is a frame populated at this location */
if (keyFrames[j])
{
currentPresence = (frameArray[i][j] != null);
}
presenceArray[i][j] = currentPresence;
}
/* executing the loop twice is the most straightforward way to ensure that a keyframe at the end
* of the timeline wraps around to the front of the timeline
* this does mess with animations that aren't looped that don't have keyframes at time = 0 but that just doesn't make
* much sense (who wouldn't keyframe at time = 0 for a non-looping animation!)
* so I'll just document that and ignore that problem for now */
}
/* for every frame with presence in the array set to true that still has a null frame
* interpolate the missing frame */
for (int i = 0; i < infoProvider.Size(); i++)
{
ProcessingFrame beforeFrame = null;
ProcessingFrame afterFrame = null;
int beforeFrameIndex = -1;
int afterFrameIndex = -1;
for (int j = 0; j < numberOfFrames; j++)
{
/* skip this frame if it isn't supposed to be present */
if (!presenceArray[i][j])
{
continue;
}
/* if this frame exists and is populated then it will be used
* as the before frame */
if (frameArray[i][j] != null && frameArray[i][j].IsPopulated())
{
beforeFrame = frameArray[i][j];
beforeFrameIndex = j;
/* probe forward to find the after array when a before array is found
* will use a endless loop because eventually at least we know we will
* terminate when it hits the exact same before array */
int jPrime = j + 1;
if (jPrime >= numberOfFrames)
{
jPrime = 0;
}
while (presenceArray[i][jPrime])
{
if (frameArray[i][jPrime] != null && frameArray[i][jPrime].IsPopulated())
{
afterFrame = frameArray[i][jPrime];
afterFrameIndex = jPrime;
break;
}
jPrime++;
if (jPrime >= numberOfFrames)
{
jPrime = 0;
}
}
/* if we found a before frame but couldn't find an after frame this means that there was a frame that is completely defined
* but there are more frames that need to be interpolated from this frame only
* since this is the only frame, spriter interprets this frame as being the frame used for all of the interpolated positions
* in which this sprite exists */
if (afterFrame == null)
{
Logger.Debug("Could not find after frame to interpolate between. Interpreting this to mean that this frame is expected to take the entire duration of the timeline.");
afterFrame = beforeFrame;
afterFrameIndex = beforeFrameIndex;
}
}
else if (beforeFrame != null && afterFrame != null)
{
float x = LinearInterpolate(beforeFrame.X, afterFrame.X, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float y = LinearInterpolate(beforeFrame.Y, afterFrame.Y, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float angle = LinearInterpolateAngle(beforeFrame.Angle, afterFrame.Angle, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float xScale = LinearInterpolate(beforeFrame.ScaleX, afterFrame.ScaleX, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float yScale = LinearInterpolate(beforeFrame.ScaleY, afterFrame.ScaleY, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
if (frameArray[i][j] == null)
{
frameArray[i][j] = new ProcessingFrame(beforeFrame.ParentId, beforeFrame.ZIndex);
}
frameArray[i][j].Populate(beforeFrame.Folder, beforeFrame.File, x, y, angle, xScale, yScale);
}
}
}
for (int i = 0; i < infoProvider.Size(); i++)
{
ProcessingFrame beforeFrame = null;
ProcessingFrame afterFrame = null;
int beforeFrameIndex = -1;
int afterFrameIndex = -1;
for (int j = 0; j < numberOfFrames; j++)
{
/* skip this frame if it isn't supposed to be present */
if (!presenceArray[i][j])
{
continue;
}
/* if this frame exists and is populated then it will be used
* as the before frame */
if (frameArray[i][j] != null && frameArray[i][j].IsPopulated())
{
beforeFrame = frameArray[i][j];
beforeFrameIndex = j;
/* probe forward to find the after array when a before array is found
* will use a endless loop because eventually at least we know we will
* terminate when it hits the exact same before array */
int jPrime = j + 1;
if (jPrime >= numberOfFrames)
{
jPrime = 0;
}
while (presenceArray[i][jPrime])
{
if (frameArray[i][jPrime] != null && frameArray[i][jPrime].IsPopulated())
{
afterFrame = frameArray[i][jPrime];
afterFrameIndex = jPrime;
break;
}
jPrime++;
if (jPrime >= numberOfFrames)
{
jPrime = 0;
}
}
/* if we found a before frame but couldn't find an after frame this means that there was a frame that is completely defined
* but there are more frames that need to be interpolated from this frame only
* since this is the only frame, spriter interprets this frame as being the frame used for all of the interpolated positions
* in which this sprite exists */
if (afterFrame == null)
{
Logger.Debug("Could not find after frame to interpolate between. Interpreting this to mean that this frame is expected to take the entire duration of the timeline.");
afterFrame = beforeFrame;
afterFrameIndex = beforeFrameIndex;
}
}
else if (beforeFrame != null && afterFrame != null)
{
float x = LinearInterpolate(beforeFrame.X, afterFrame.X, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float y = LinearInterpolate(beforeFrame.Y, afterFrame.Y, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float angle = LinearInterpolateAngle(beforeFrame.Angle, afterFrame.Angle, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float xScale = LinearInterpolate(beforeFrame.ScaleX, afterFrame.ScaleX, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
float yScale = LinearInterpolate(beforeFrame.ScaleY, afterFrame.ScaleY, beforeFrameIndex,
afterFrameIndex + ((afterFrameIndex < beforeFrameIndex) ? numberOfFrames : 0), j);
if (frameArray[i][j] == null)
{
frameArray[i][j] = new ProcessingFrame(beforeFrame.ParentId, beforeFrame.ZIndex);
}
frameArray[i][j].Populate(beforeFrame.Folder, beforeFrame.File, x, y, angle, xScale, yScale);
}
}
}
/* interpolation is run twice to fix issue where time = 0 is not key frame */
return(new ProcessingAnimation(name, interval, length, frameArray, infoProvider));
}