private static Animation CreateAnimation(SerializableAnimation animationContent)
{
Animation animation = new Animation(animationContent.name);
animation.SetLength(animationContent.length);
foreach (SerializableTrack trackContent in animationContent.tracks)
{
AnimationTrack track = animation.CreateTrack(trackContent.name);
for (int i = 0; i < trackContent.keyframes.Count; i++)
{
SerializableKeyFrame keyFrameContent = trackContent.keyframes[i];
AnimationKeyFrame keyFrame = new AnimationKeyFrame
{
rotation = keyFrameContent.rotation,
scale = keyFrameContent.scale,
translation = keyFrameContent.translation,
time = keyFrameContent.time
};
track.AddKeyFrame(keyFrame);
}
}
return(animation);
}
private void testNullKeyFrame(AnimationKeyFrame frame)
{
Assert.AreEqual(0.0f, frame.rot.X, TOLERANCE);
Assert.AreEqual(0.0f, frame.rot.Y, TOLERANCE);
Assert.AreEqual(0.0f, frame.rot.Z, TOLERANCE);
Assert.AreEqual(0.0f, frame.rot.W, TOLERANCE);
Assert.AreEqual(0.0f, frame.pos.X, TOLERANCE);
Assert.AreEqual(0.0f, frame.pos.Y, TOLERANCE);
Assert.AreEqual(0.0f, frame.pos.Z, TOLERANCE);
}
public override void AddPoint(WindowsPoint point)
{
var realPoint = InverseTransformPoint(point);
var keyFrame = new AnimationKeyFrame <float>
{
Key = realPoint.X,
Value = realPoint.Y,
};
var index = GetInsertIndex(realPoint);
KeyFramesNode.Add(keyFrame, index);
}
public void Update(float elapsed)
{
foreach (AnimationState state in animationStates)
{
if (!state.IsActive())
{
continue;
}
Animation animation = state.GetAnimation();
state.Update(elapsed);
float timePosition = state.GetTimePosition();
for (int i = 0; i < animation.GetTrackCount(); i++)
{
AnimationTrack track = animation.GetTrack(i);
AnimationKeyFrame keyframe = track.GetInterpolatedKeyFrame(timePosition);
int boneIndex = skeleton.GetBoneIndexByName(track.GetName());
keyframe.GetMatrix(out animationTransforms[boneIndex]);
}
}
// convert animation transforms from local to world coordinates
for (int i = 0; i < animationTransforms.Length; i++)
{
int parent = skeleton.GetParentBoneIndexByIndex(i);
if (parent == -1)
{
continue;
}
Matrix.Multiply(ref animationTransforms[i], ref animationTransforms[parent], out animationTransforms[i]);
}
// create the skinning matrix
// the skinning matrix takes world space vertices to joint space and then back
// to world space using the animation transform
for (int i = 0; i < animationTransforms.Length; i++)
{
Matrix invWorldBoneMatrix;
AnimationBone bone = skeleton.GetBoneByIndex(i);
bone.GetInvWorldTransform(out invWorldBoneMatrix);
Matrix.Multiply(ref invWorldBoneMatrix, ref animationTransforms[i], out animationTransforms[i]);
}
effect.SetBoneTransforms(animationTransforms);
effect.World = world;
}
private static void InitializeHandleOpacityStoryboard(IAnimationStoryboard storyboard, IAnimationVariable variable, double startOffsetPeriodFraction)
{
AnimationSeconds duration = 2.0;
AnimationSeconds seconds2 = duration * startOffsetPeriodFraction;
if (seconds2 != 0.0)
{
AnimationTransition transition2 = new ConstantAnimationTransition(seconds2);
storyboard.AddTransition(variable, transition2);
}
AnimationKeyFrame startKeyFrame = storyboard.AddKeyFrameAtOffset(AnimationKeyFrame.StoryboardStart, seconds2);
AnimationTransition transition = new SinusoidalFromRangeAnimationTransition(duration, 0.25, 1.5, duration, AnimationSlope.Decreasing);
storyboard.AddTransition(variable, transition);
AnimationKeyFrame endKeyFrame = storyboard.AddKeyFrameAfterTransition(transition);
storyboard.RepeatBetweenKeyFrames(startKeyFrame, endKeyFrame, -1);
}
/// <inheritdoc/>
public sealed override void AddPoint(WindowsPoint point)
{
var realPoint = InverseTransformPoint(point);
// Make sure the curve is sampled
UnderlyingCurve.UpdateChanges();
// Evaluate the current value
var value = UnderlyingCurve.Evaluate(realPoint.X);
UpdateComponent(ref value, realPoint);
var keyFrame = new AnimationKeyFrame <TValue>
{
Key = realPoint.X,
Value = value,
};
var index = GetInsertIndex(realPoint);
KeyFramesNode.Add(keyFrame, index);
}
/// <inheritdoc/>
public override void AddPoint(WindowsPoint point)
{
var realPoint = InverseTransformPoint(point);
// Make sure the curve is sampled
UnderlyingCurve.UpdateChanges();
// Evaluate the current value
var value = UnderlyingCurve.Evaluate(realPoint.X);
// Update the component that is handled by this curve
switch (Component)
{
case VectorComponent.X:
value.X = realPoint.Y;
break;
case VectorComponent.Y:
value.Y = realPoint.Y;
break;
case VectorComponent.Z:
value.Z = realPoint.Y;
break;
case VectorComponent.W:
value.Z = realPoint.Y;
break;
default:
throw new NotSupportedException(); // This should never happen
}
// Create a new keyframe
var keyFrame = new AnimationKeyFrame <Quaternion>
{
Key = realPoint.X,
Value = value,
};
var index = GetInsertIndex(realPoint);
KeyFramesNode.Add(keyFrame, index);
}
public override Task <Entity> CreateEntity(EntityHierarchyItemViewModel parent)
{
var name = ComputeNewName(parent, "Ribbon particle system");
var component = new ParticleSystemComponent();
var emitter = new ParticleEmitter {
ParticleLifetime = new Vector2(2, 2)
};
// 30 Particles per second
var spawner = new SpawnerPerSecond {
SpawnCount = 30
};
emitter.Spawners.Add(spawner);
// Ribbon
var ribbonShape = new ShapeBuilderRibbon
{
SmoothingPolicy = SmoothingPolicy.Best,
Segments = 15,
TextureCoordinatePolicy = TextureCoordinatePolicy.Stretched,
TexCoordsFactor = 1f
};
emitter.ShapeBuilder = ribbonShape;
// Velocity
var randVel = new InitialVelocitySeed
{
VelocityMin = new Vector3(-0.15f, 3f, -0.15f),
VelocityMax = new Vector3(0.15f, 3, 0.15f)
};
emitter.Initializers.Add(randVel);
// Spawn Order
var initialOrder = new InitialSpawnOrder();
emitter.Initializers.Add(initialOrder);
// Size by Lifetime
var sizeCurve = new ComputeAnimationCurveFloat();
var key0 = new AnimationKeyFrame <float>
{
Key = 0,
Value = 0.1f
};
var key1 = new AnimationKeyFrame <float>
{
Key = 0.9f,
Value = 0f
};
sizeCurve.KeyFrames.Add(key0);
sizeCurve.KeyFrames.Add(key1);
var sizeAnimation = new UpdaterSizeOverTime {
SamplerMain = { Curve = sizeCurve }
};
emitter.Updaters.Add(sizeAnimation);
emitter.SortingPolicy = EmitterSortingPolicy.ByOrder;
component.ParticleSystem.Emitters.Add(emitter);
return(CreateEntityWithComponent(name, component));
}
