public static PropertyAnimation Read(BlockReader reader, ActorComponent component)
{
BlockReader propertyBlock = reader.ReadNextBlock();
if (propertyBlock == null)
{
return(null);
}
PropertyAnimation propertyAnimation = new PropertyAnimation();
int type = propertyBlock.BlockType;
if (!Enum.IsDefined(typeof(PropertyTypes), type))
{
return(null);
}
else
{
propertyAnimation.m_Type = (PropertyTypes)type;
Func <BinaryReader, ActorComponent, KeyFrame> keyFrameReader = null;
switch (propertyAnimation.m_Type)
{
case PropertyTypes.PosX:
keyFrameReader = KeyFramePosX.Read;
break;
case PropertyTypes.PosY:
keyFrameReader = KeyFramePosY.Read;
break;
case PropertyTypes.ScaleX:
keyFrameReader = KeyFrameScaleX.Read;
break;
case PropertyTypes.ScaleY:
keyFrameReader = KeyFrameScaleY.Read;
break;
case PropertyTypes.Rotation:
keyFrameReader = KeyFrameRotation.Read;
break;
case PropertyTypes.Opacity:
keyFrameReader = KeyFrameOpacity.Read;
break;
case PropertyTypes.DrawOrder:
keyFrameReader = KeyFrameDrawOrder.Read;
break;
case PropertyTypes.Length:
keyFrameReader = KeyFrameLength.Read;
break;
case PropertyTypes.VertexDeform:
keyFrameReader = KeyFrameVertexDeform.Read;
break;
case PropertyTypes.ConstraintStrength:
keyFrameReader = KeyFrameConstraintStrength.Read;
break;
case PropertyTypes.Trigger:
keyFrameReader = KeyFrameTrigger.Read;
break;
case PropertyTypes.IntProperty:
keyFrameReader = KeyFrameIntProperty.Read;
break;
case PropertyTypes.FloatProperty:
keyFrameReader = KeyFrameFloatProperty.Read;
break;
case PropertyTypes.StringProperty:
keyFrameReader = KeyFrameStringProperty.Read;
break;
case PropertyTypes.BooleanProperty:
keyFrameReader = KeyFrameBooleanProperty.Read;
break;
case PropertyTypes.CollisionEnabled:
keyFrameReader = KeyFrameCollisionEnabledProperty.Read;
break;
case PropertyTypes.ActiveChildIndex:
keyFrameReader = KeyFrameActiveChild.Read;
break;
}
int keyFrameCount = propertyBlock.ReadUInt16();
propertyAnimation.m_KeyFrames = new KeyFrame[keyFrameCount];
KeyFrame lastKeyFrame = null;
for (int i = 0; i < keyFrameCount; i++)
{
KeyFrame frame = keyFrameReader(propertyBlock, component);
propertyAnimation.m_KeyFrames[i] = frame;
if (lastKeyFrame != null)
{
lastKeyFrame.SetNext(frame);
}
lastKeyFrame = frame;
}
}
return(propertyAnimation);
}
//Animation.prototype.triggerEvents = function(actorComponents, fromTime, toTime, triggered)
/*
* name:component._Name,
* component:component,
* propertyType:property._Type,
* keyFrameTime:toTime,
* elapsed:0*/
public void TriggerEvents(ActorComponent[] components, float fromTime, float toTime, IList <AnimationEventArgs> triggerEvents)
{
for (int i = 0; i < m_TriggerComponents.Length; i++)
{
ComponentAnimation keyedComponent = m_TriggerComponents[i];
foreach (PropertyAnimation property in keyedComponent.Properties)
{
switch (property.PropertyType)
{
case PropertyTypes.Trigger:
IList <KeyFrame> keyFrames = property.KeyFrames;
int kfl = keyFrames.Count;
if (kfl == 0)
{
continue;
}
int idx = 0;
// Binary find the keyframe index.
{
int mid = 0;
float element = 0.0f;
int start = 0;
int end = kfl - 1;
while (start <= end)
{
mid = ((start + end) >> 1);
element = keyFrames[mid].Time;
if (element < toTime)
{
start = mid + 1;
}
else if (element > toTime)
{
end = mid - 1;
}
else
{
start = mid;
break;
}
}
idx = start;
}
//int idx = keyFrameLocation(toTime, keyFrames, 0, keyFrames.length-1);
if (idx == 0)
{
if (kfl > 0 && keyFrames[0].Time == toTime)
{
ActorComponent component = components[keyedComponent.ComponentIndex];
triggerEvents.Add(new AnimationEventArgs(component.Name, component, property.PropertyType, toTime, 0.0f));
}
}
else
{
for (int k = idx - 1; k >= 0; k--)
{
KeyFrame frame = keyFrames[k];
if (frame.Time > fromTime)
{
ActorComponent component = components[keyedComponent.ComponentIndex];
triggerEvents.Add(new AnimationEventArgs(component.Name, component, property.PropertyType, frame.Time, toTime - frame.Time));
/*triggered.push({
* name:component._Name,
* component:component,
* propertyType:property._Type,
* keyFrameTime:frame._Time,
* elapsed:toTime-frame._Time
* });*/
}
else
{
break;
}
}
}
break;
default:
break;
}
}
}
}
abstract public bool SetNextFrame(KeyFrameWithInterpolation frame, KeyFrame nextFrame);
public void Apply(float time, ActorComponent component, float mix)
{
if (m_KeyFrames.Length == 0)
{
return;
}
int idx = 0;
// Binary find the keyframe index.
{
int mid = 0;
float element = 0.0f;
int start = 0;
int end = m_KeyFrames.Length - 1;
while (start <= end)
{
mid = ((start + end) >> 1);
element = m_KeyFrames[mid].Time;
if (element < time)
{
start = mid + 1;
}
else if (element > time)
{
end = mid - 1;
}
else
{
start = mid;
break;
}
}
idx = start;
}
if (idx == 0)
{
m_KeyFrames[0].Apply(component, mix);
}
else
{
if (idx < m_KeyFrames.Length)
{
KeyFrame fromFrame = m_KeyFrames[idx - 1];
KeyFrame toFrame = m_KeyFrames[idx];
if (time == toFrame.Time)
{
toFrame.Apply(component, mix);
}
else
{
fromFrame.ApplyInterpolation(component, time, toFrame, mix);
}
}
else
{
m_KeyFrames[idx - 1].Apply(component, mix);
}
}
}
public override void SetNext(KeyFrame frame)
{
// No Interpolation
}
public override void ApplyInterpolation(ActorComponent component, float time, KeyFrame toFrame, float mix)
{
Apply(component, mix);
}
public override void ApplyInterpolation(ActorComponent component, float time, KeyFrame toFrame, float mix)
{
ActorImage imageNode = component as ActorImage;
float[] wr = imageNode.AnimationDeformedVertices;
float[] to = (toFrame as KeyFrameVertexDeform).m_Vertices;
int l = m_Vertices.Length;
float f = (time - m_Time) / (toFrame.Time - m_Time);
float fi = 1.0f - f;
if (mix == 1.0f)
{
for (int i = 0; i < l; i++)
{
wr[i] = m_Vertices[i] * fi + to[i] * f;
}
}
else
{
float mixi = 1.0f - mix;
for (int i = 0; i < l; i++)
{
float v = m_Vertices[i] * fi + to[i] * f;
wr[i] = wr[i] * mixi + v * mix;
}
}
imageNode.IsVertexDeformDirty = true;
}
public override void SetNext(KeyFrame frame)
{
// Do nothing.
}
public abstract void ApplyInterpolation(ActorComponent component, float time, KeyFrame toFrame, float mix);
public abstract void SetNext(KeyFrame frame);
public static bool Read(BinaryReader reader, KeyFrame frame)
{
frame.m_Time = (float)reader.ReadDouble();
return(true);
}
public override void ApplyInterpolation(ActorComponent component, float time, KeyFrame toFrame, float mix)
{
switch (m_InterpolationType)
{
case KeyFrame.InterpolationTypes.Mirrored:
case KeyFrame.InterpolationTypes.Asymmetric:
case KeyFrame.InterpolationTypes.Disconnected:
{
ValueTimeCurveInterpolator interpolator = m_Interpolator as ValueTimeCurveInterpolator;
if (interpolator != null)
{
float v = (float)interpolator.Get((double)time);
SetValue(component, v, mix);
}
break;
}
case KeyFrame.InterpolationTypes.Hold:
{
SetValue(component, m_Value, mix);
break;
}
case KeyFrame.InterpolationTypes.Linear:
{
KeyFrameInt to = toFrame as KeyFrameInt;
float f = (time - m_Time) / (to.m_Time - m_Time);
SetValue(component, m_Value * (1.0f - f) + to.m_Value * f, mix);
break;
}
}
}
public override bool SetNextFrame(KeyFrameWithInterpolation frame, KeyFrame nextFrame)
{
return(false);
}
