private void AnimationFinishedCallback(AnimationInstance animation) { PlayerAnimations.Id id = (PlayerAnimations.Id)animation.id; switch (id) { case PlayerAnimations.Id.Die: { Debug.Assert(!IsAlive); RemoveFromField(); break; } case PlayerAnimations.Id.PunchBomb: { IsPunchingBomb = false; break; } case PlayerAnimations.Id.PickupBomb: { IsPickingUpBomb = false; break; } } }
public TestScreen() { animationLookup = new Dictionary <AnimationId, AnimationContainer>(); AnimationContainer container; container = new AnimationContainer(); container.up = GetAnimation(A.anim_stand_north); container.down = GetAnimation(A.anim_stand_south); container.left = GetAnimation(A.anim_stand_west); container.right = GetAnimation(A.anim_stand_east); animationLookup[AnimationId.Stand] = container; container = new AnimationContainer(); container.up = GetAnimation(A.anim_walk_north); container.down = GetAnimation(A.anim_walk_south); container.left = GetAnimation(A.anim_walk_west); container.right = GetAnimation(A.anim_walk_east); animationLookup[AnimationId.Walk] = container; container = new AnimationContainer(); container.up = GetAnimation(A.anim_kick_north); container.down = GetAnimation(A.anim_kick_south); container.left = GetAnimation(A.anim_kick_west); container.right = GetAnimation(A.anim_kick_east); animationLookup[AnimationId.Kick] = container; groupInstance = new AnimationInstance(); groupInstance.Init(GetAnimation(A.anim_die_green_1)); }
/// <summary> /// Initializes a new instance of the <see cref="ReplaceTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="previousAnimation"/> is <see langword="null"/>. /// </exception> public ReplaceTransition(AnimationInstance previousAnimation) { if (previousAnimation == null) throw new ArgumentNullException("previousAnimation"); _previousAnimation = previousAnimation; }
void LoadAnimations() { // clear current state curAnimationInstance_ = -1; instances_ = null; blended_ = null; // get the list of animations from our dictionary Dictionary <string, object> tag = loadedModel_.Model.Tag as Dictionary <string, object>; object aobj = null; if (tag != null) { tag.TryGetValue("AnimationSet", out aobj); } animations_ = aobj as AnimationSet; // set up animations if (animations_ != null) { instances_ = new AnimationInstance[animations_.NumAnimations]; // I'll need a BlendedAnimation per animation, so that I can let the // blender object transition between them. blended_ = new IBlendedAnimation[instances_.Length]; int ix = 0; foreach (Animation a in animations_.Animations) { instances_[ix] = new AnimationInstance(a); blended_[ix] = AnimationBlender.CreateBlendedAnimation(instances_[ix]); ++ix; } } }
//update... public UpdateFrequency Update(UpdateState state) { //when pressing A, create a new avatar description if (state.PlayerInput[PlayerIndex.One].InputState.Buttons.A.OnPressed) { this.avatar.AvatarDescription = Microsoft.Xna.Framework.GamerServices.AvatarDescription.CreateRandom(); } //if pressing B, play the cheer animation if (state.PlayerInput[PlayerIndex.One].InputState.Buttons.B.OnPressed) { //start or stop the cheer animation (which is a built in animation in XNA) //use a fadein / fadeout if (!cheerAnimation.AnimationFinished) { cheerAnimation.StopAnimation(0.5f); } else { cheerAnimation = animationController.PlayPresetAnimation(AvatarAnimationPreset.Celebrate, true, 0.5f, 0.5f); } } //when the cheer animation is playing, fade the walking animation out, //do this based on the opposite weighitng of the cheer animation (taking fading into account) this.walkAnimation.Weighting = 1 - this.cheerAnimation.GetFadeScaledWeighting(state); return(UpdateFrequency.FullUpdate60hz); }
/// <summary> /// Combines the new animation with existing animations by inserting the new animation after the /// specified animation into the composition chains. The new animation fades in over the /// specified duration. /// </summary> /// <param name="previousAnimation"> /// The animation after which the new animation should be added. /// </param> /// <param name="fadeInDuration">The duration over which the new animation fades in.</param> /// <returns>The <see cref="AnimationTransition"/>.</returns> public static AnimationTransition Compose(AnimationInstance previousAnimation, TimeSpan fadeInDuration) { if (fadeInDuration > TimeSpan.Zero) return new FadeInAndComposeTransition(previousAnimation, fadeInDuration); return new ComposeTransition(previousAnimation); }
private void InitaliseAnimations(UpdateManager updateManager) { //create the controller as an asynchronous controller. //this will process animations as a thread task //This occurs between the update loop and the draw loop, //which is why the UpdateManager must be provided. control = model.GetAsyncAnimationController(updateManager); //these perform a linear search to find the animation index int idleAnimationIndex = control.AnimationIndex("Loiter"); int jogAnimationIndex = control.AnimationIndex("Jog"); int walkAnimationIndex = control.AnimationIndex("Walk"); //create the idle animation idle = control.PlayLoopingAnimation(idleAnimationIndex); //give it a random speed idle.PlaybackSpeed = (float)random.NextDouble() * 0.5f + 0.6f; if (moveSpeed > 0.75) { //run animation move = control.PlayLoopingAnimation(jogAnimationIndex); // play a jogging animation move.PlaybackSpeed = 0.5f; } else { //walk animation move = control.PlayLoopingAnimation(walkAnimationIndex); // play a walking animation } //initially don't want the move animation being visible move.Weighting = 0; }
private void SetActiveAnimationState(AnimationState animationState) { if (_activeAnimationState == animationState || _activeModelDrawConditionState == null) { return; } var modelInstance = _activeModelDrawConditionState.Model; var firstAnimationBlock = animationState.Animations .FirstOrDefault(); if (firstAnimationBlock != null) { foreach (var animation in firstAnimationBlock.Animations) { var anim = animation.Value; //Check if the animation does really exist if (anim != null) { var animationInstance = new AnimationInstance(modelInstance, anim); modelInstance.AnimationInstances.Add(animationInstance); animationInstance.Play(); break; } } } }
/// <summary> /// Setup bone attachment. /// </summary> /// <param name="animator"></param> /// <param name="parentBone"></param> public virtual void SetBone(AnimationInstance animator, ModelBone parentBone) { this.parentBone = parentBone; this.animator = animator; UpdateTransforms(); }
void DrawAnimInstance(AnimationInstance ai) { int index = sequence.animations.IndexOf(ai); showData[index] = EditorGUILayout.Foldout(showData[index], "" + ai.animationData.name + " " + ai.startTime + " -> " + (ai.startTime + ai.animationData.duration)); if (showData[index]) { ai.animationData = (AnimationData)EditorGUILayout.ObjectField("Data", ai.animationData, typeof(AnimationData), true); ai.itemIndex = EditorGUILayout.Popup("Item", ai.itemIndex, sequence.itemNames.ToArray()); EditorGUIUtility.fieldWidth = 20; EditorGUIUtility.labelWidth = 80; EditorGUILayout.BeginHorizontal(); ai.startTime = EditorGUILayout.FloatField("StartTime ", ai.startTime); if (!ai.animationData.SetValue) { ai.animationData.duration = EditorGUILayout.FloatField("Duration ", ai.animationData.duration); } EditorGUILayout.EndHorizontal(); EditorGUIUtility.fieldWidth = 0; EditorGUIUtility.labelWidth = 0; EditorGUILayout.LabelField("EndTime : " + (ai.startTime + ai.animationData.duration)); } }
/// <summary> /// Construct self from a model and active animation name. /// </summary> /// <param name="model"></param> /// <param name="animName"></param> public ModelAnim(FBXModel model, string animName) { ActiveAnimation = new AnimatorList(model); if (ActiveAnimation.NotEmpty) { AnimationInstance sample = ActiveAnimation.Sample; ActiveController = SimpleController.TryMake(sample, animName, sample.FirstAnimationName); if (ActiveController != null) { ActiveAnimation.ApplyController(ActiveController); IdleAnimation = new AnimatorList(model); Debug.Assert(IdleAnimation.NotEmpty, "Could make active but not idle?"); sample = IdleAnimation.Sample; IdleController = SimpleController.TryMake(sample, "idle", null); if (IdleController != null) { IdleAnimation.ApplyController(IdleController); } else { IdleAnimation = null; } } else { ActiveAnimation = null; } } }
/// <summary> /// Initializes a new instance of the <see cref="FadeInAndComposeTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <param name="fadeInDuration">The duration over which the new animation fades in.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="fadeInDuration"/> is 0 or negative. /// </exception> public FadeInAndComposeTransition(AnimationInstance previousAnimation, TimeSpan fadeInDuration) { if (fadeInDuration <= TimeSpan.Zero) throw new ArgumentOutOfRangeException("fadeInDuration", "The fade-in duration must be greater than 0."); _previousAnimation = previousAnimation; _fadeInDuration = fadeInDuration; }
public void ShouldImplementIList() { var property = new AnimatableProperty <float>(); var compositionChain = AnimationCompositionChain <float> .Create(property, SingleTraits.Instance); var list = (IList <AnimationInstance>)compositionChain; var animationInstance0 = AnimationInstance <float> .Create(new SingleFromToByAnimation()); var animationInstance1 = AnimationInstance <float> .Create(new SingleFromToByAnimation()); var animationInstance2 = AnimationInstance <float> .Create(new SingleFromToByAnimation()); var wrongInstance = AnimationInstance.Create(new TimelineGroup()); // The enumerator is not implemented (to prevent garbage). Assert.That(() => { list.GetEnumerator(); }, Throws.TypeOf <NotImplementedException>()); // Add Assert.That(() => list.Add(wrongInstance), Throws.ArgumentException); list.Add(animationInstance0); // Contains Assert.IsTrue(list.Contains(animationInstance0)); Assert.IsFalse(list.Contains(animationInstance1)); Assert.IsFalse(list.Contains(wrongInstance)); // IndexOf Assert.AreEqual(0, list.IndexOf(animationInstance0)); Assert.AreEqual(-1, list.IndexOf(animationInstance1)); Assert.AreEqual(-1, list.IndexOf(wrongInstance)); // IsReadOnly Assert.IsFalse(list.IsReadOnly); // Insert list.Insert(1, animationInstance1); Assert.That(() => list.Insert(0, wrongInstance), Throws.ArgumentException); // Indexer Assert.AreEqual(animationInstance1, list[1]); list[0] = animationInstance2; Assert.That(() => list[0] = wrongInstance, Throws.ArgumentException); // CopyTo AnimationInstance[] array = new AnimationInstance[2]; list.CopyTo(array, 0); Assert.AreEqual(animationInstance2, array[0]); Assert.AreEqual(animationInstance1, array[1]); // Remove Assert.IsTrue(list.Remove(animationInstance2)); Assert.AreEqual(1, list.Count); Assert.IsFalse(list.Remove(wrongInstance)); // RemoveAt list.RemoveAt(0); Assert.AreEqual(0, list.Count); }
private void DrawPlayer(Context context, Player player) { TextureImage image = TempFindPlayerImage(player); float drawX = player.GetPx() - 0.5f * cellWidth; float drawY = player.GetPy() - 0.5f * cellHeight; if (CVars.g_drawPlayerCell.boolValue) { context.DrawRect(player.GetCx() * cellWidth, player.GetCy() * cellHeight, cellWidth, cellHeight, Color.White); } if (CVars.g_drawPlayerMovable.boolValue) { context.DrawRect(drawX, drawY, cellWidth, cellHeight, Color.Yellow); } if (player.IsInfected()) { if (blink) { AnimationInstance anim = player.currentAnimation; anim.Draw(context, drawX + 0.5f * cellWidth, drawY + cellHeight); } } else { AnimationInstance anim = player.currentAnimation; anim.Draw(context, drawX + 0.5f * cellWidth, drawY + cellHeight); } if (CVars.g_drawPlayerStepRect.boolValue) { int stepX = Math.Sign(player.px - player.CellCenterPx()); int stepY = Math.Sign(player.py - player.CellCenterPy()); bool hasStepX = stepX != 0; bool hasStepY = stepY != 0; int cx = player.GetCx(); int cy = player.GetCy(); if (hasStepX && hasStepY) { DrawCellRect(context, cx + stepX, cy, Color.Yellow); DrawCellRect(context, cx, cy + stepY, Color.Yellow); DrawCellRect(context, cx + stepX, cy + stepY, Color.Yellow); } else if (hasStepX) { DrawCellRect(context, cx + stepX, cy, Color.Yellow); } else if (hasStepY) { DrawCellRect(context, cx, cy + stepY, Color.Yellow); } } }
void SetupInstance(int animationIndex, int startTime, byte remapFace) { currentAnimationIndex = animationIndex; EditDataSet tempEditSet = AppDataSet.Instance.ExtractEditSetForAnimation(animations[animationIndex]); dataSet = tempEditSet.ToDataSet(); currentInstance = dataSet.animations[0].CreateInstance(dataSet.animationBits); currentInstance.start(startTime, remapFace, false); }
/// <summary> /// Initializes a new instance of the <see cref="ReplaceTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="previousAnimation"/> is <see langword="null"/>. /// </exception> public ReplaceTransition(AnimationInstance previousAnimation) { if (previousAnimation == null) { throw new ArgumentNullException("previousAnimation"); } _previousAnimation = previousAnimation; }
/// <summary> /// Set the owner actor. /// </summary> /// <param name="owner"></param> /// <param name="parentBone"></param> public virtual void SetOwner(GameActor owner) { this.owner = owner; int lod = Math.Max(0, owner.Animators.Count - 1); this.animator = owner.Animators[lod]; UpdateTransforms(); }
/// <summary> /// Setup bone attachment. /// </summary> /// <param name="animator"></param> /// <param name="parentBone"></param> public override void SetBone(AnimationInstance animator, ModelBone parentBone) { base.SetBone(animator, parentBone); foreach (Rectangle rect in sides) { rect.SetBone(animator, parentBone); } }
AnimationInstance ITimeline.CreateInstance() { if (!IsFrozen) { throw new AnimationException("This animation is not frozen. Freeze() must be called before the animation can be used."); } return(AnimationInstance <SkeletonPose> .Create(this)); }
public BlueprintsExtensibility() { blueprintActor = Blueprint.Load("/Game/Tests/BlueprintActor"); blueprintSceneComponent = Blueprint.Load("/Game/Tests/BlueprintSceneComponent"); actor = new Actor(blueprint: blueprintActor); sceneComponent = new SceneComponent(actor, blueprint: blueprintSceneComponent); levelScript = World.GetActor <LevelScript>(); skeletalMeshComponent = actor.GetComponent <SkeletalMeshComponent>(); animationInstance = skeletalMeshComponent.GetAnimationInstance(); }
public void ClearAnimations() { // Shouldn't have an instance if we don't have an animation currentInstance = null; dataSet = null; currentState = State.Idle; // Clear the animation animations.Clear(); }
/// <summary> /// Initializes a new instance of the <see cref="FadeInAndComposeTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <param name="fadeInDuration">The duration over which the new animation fades in.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="fadeInDuration"/> is 0 or negative. /// </exception> public FadeInAndComposeTransition(AnimationInstance previousAnimation, TimeSpan fadeInDuration) { if (fadeInDuration <= TimeSpan.Zero) { throw new ArgumentOutOfRangeException("fadeInDuration", "The fade-in duration must be greater than 0."); } _previousAnimation = previousAnimation; _fadeInDuration = fadeInDuration; }
public void ShouldImplementIList() { var property = new AnimatableProperty<float>(); var compositionChain = AnimationCompositionChain<float>.Create(property, SingleTraits.Instance); var list = (IList<AnimationInstance>)compositionChain; var animationInstance0 = AnimationInstance<float>.Create(new SingleFromToByAnimation()); var animationInstance1 = AnimationInstance<float>.Create(new SingleFromToByAnimation()); var animationInstance2 = AnimationInstance<float>.Create(new SingleFromToByAnimation()); var wrongInstance = AnimationInstance.Create(new TimelineGroup()); // The enumerator is not implemented (to prevent garbage). Assert.That(() => { list.GetEnumerator(); }, Throws.TypeOf<NotImplementedException>()); // Add Assert.That(() => list.Add(wrongInstance), Throws.ArgumentException); list.Add(animationInstance0); // Contains Assert.IsTrue(list.Contains(animationInstance0)); Assert.IsFalse(list.Contains(animationInstance1)); Assert.IsFalse(list.Contains(wrongInstance)); // IndexOf Assert.AreEqual(0, list.IndexOf(animationInstance0)); Assert.AreEqual(-1, list.IndexOf(animationInstance1)); Assert.AreEqual(-1, list.IndexOf(wrongInstance)); // IsReadOnly Assert.IsFalse(list.IsReadOnly); // Insert list.Insert(1, animationInstance1); Assert.That(() => list.Insert(0, wrongInstance), Throws.ArgumentException); // Indexer Assert.AreEqual(animationInstance1, list[1]); list[0] = animationInstance2; Assert.That(() => list[0] = wrongInstance, Throws.ArgumentException); // CopyTo AnimationInstance[] array = new AnimationInstance[2]; list.CopyTo(array, 0); Assert.AreEqual(animationInstance2, array[0]); Assert.AreEqual(animationInstance1, array[1]); // Remove Assert.IsTrue(list.Remove(animationInstance2)); Assert.AreEqual(1, list.Count); Assert.IsFalse(list.Remove(wrongInstance)); // RemoveAt list.RemoveAt(0); Assert.AreEqual(0, list.Count); }
protected virtual bool SetActiveAnimationState(AnimationState animationState, Random random) { if (animationState == _activeAnimationState && (_activeModelDrawConditionState?.StillActive() ?? false)) { return(false); } if (animationState == null || animationState.Animations.Count == 0 || _activeModelDrawConditionState == null) { return(true); } PreviousAnimationState = _activeAnimationState; if (_activeModelDrawConditionState?.Model != null) { foreach (var animationInstance in _activeModelDrawConditionState.Model.AnimationInstances) { animationInstance.Stop(); } } var modelInstance = _activeModelDrawConditionState.Model; modelInstance.AnimationInstances.Clear(); _activeAnimationState = animationState; var animationBlock = animationState.Animations[random.Next(0, animationState.Animations.Count - 1)]; if (animationBlock != null) { var anim = animationBlock.Animation.Value; //Check if the animation does really exist if (anim != null) { var flags = animationState.Flags; var mode = animationBlock.AnimationMode; var animationInstance = new AnimationInstance(modelInstance.ModelBoneInstances, anim, mode, flags, GameObject, _context.Random); modelInstance.AnimationInstances.Add(animationInstance); animationInstance.Play(animationBlock.AnimationSpeedFactorRange.GetValue(random)); } } if (animationState != null && animationState.Script != null) { _context.Scene3D.Game.Lua.ExecuteDrawModuleLuaCode(this, animationState.Script); } NLog.LogManager.GetCurrentClassLogger().Info($"Set active animation state for {GameObject.Definition.Name}"); return(true); }
/// <summary> /// Initializes a new instance of the <see cref="FadeInAndReplaceTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <param name="fadeInDuration">The duration over which the new animation fades in.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="previousAnimation"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="fadeInDuration"/> is 0 or negative. /// </exception> public FadeInAndReplaceTransition(AnimationInstance previousAnimation, TimeSpan fadeInDuration) { if (previousAnimation == null) throw new ArgumentNullException("previousAnimation"); if (fadeInDuration <= TimeSpan.Zero) throw new ArgumentOutOfRangeException("fadeInDuration", "The fade-in duration must be greater than 0."); _previousAnimation = previousAnimation; _previousAnimationRunCount = previousAnimation.RunCount; _fadeInDuration = fadeInDuration; }
/// <summary> /// Runs the KeyFrames Animation. /// </summary> internal IDisposable Run(Animation animation, Animatable control, IClock clock, Action onComplete) { var instance = new AnimationInstance <T>( animation, control, this, clock ?? control.Clock ?? Clock.GlobalClock, onComplete, InterpolationHandler); return(control.Bind <T>((AvaloniaProperty <T>)Property, instance, BindingPriority.Animation)); }
/// <summary> /// Runs the KeyFrames Animation. /// </summary> internal IDisposable Run(Animation animation, Animatable control, IClock?clock, Action?onComplete) { var instance = new AnimationInstance <T>( animation, control, this, clock ?? control.Clock ?? Clock.GlobalClock, onComplete, InterpolationHandler); return(BindAnimation(control, instance)); }
public void OnBeginPlay() { World.GetFirstPlayerController().SetViewTarget(World.GetActor <Camera>("MainCamera")); SkeletalMesh prototypeMesh = SkeletalMesh.Load("/Game/Tests/Characters/Prototype"); Actor leftPrototype = new("leftPrototype"); SkeletalMeshComponent leftSkeletalMeshComponent = new(leftPrototype); leftSkeletalMeshComponent.SetSkeletalMesh(prototypeMesh); leftSkeletalMeshComponent.SetWorldLocation(new(-700.0f, -70.0f, -100.0f)); leftSkeletalMeshComponent.SetWorldRotation(Maths.Euler(0.0f, 0.0f, 90.0f)); leftSkeletalMeshComponent.SetAnimationMode(AnimationMode.Asset); leftSkeletalMeshComponent.PlayAnimation(AnimationSequence.Load("/Game/Tests/Characters/Animations/IdleAnimationSequence"), true); Assert.IsTrue(leftSkeletalMeshComponent.IsPlaying); Assert.IsTrue(leftSkeletalMeshComponent.GetBoneName(0) == "root"); Bounds leftSkeletalMeshComponentBounds = default; leftSkeletalMeshComponent.GetBounds(leftSkeletalMeshComponent.GetTransform(), ref leftSkeletalMeshComponentBounds); Assert.IsFalse(leftSkeletalMeshComponentBounds == default(Bounds)); Actor rightPrototype = new("rightPrototype"); SkeletalMeshComponent rightSkeletalMeshComponent = new(rightPrototype); rightSkeletalMeshComponent.SetSkeletalMesh(prototypeMesh); rightSkeletalMeshComponent.SetWorldLocation(new(-700.0f, 70.0f, -100.0f)); rightSkeletalMeshComponent.SetWorldRotation(Maths.Euler(0.0f, 0.0f, 90.0f)); rightSkeletalMeshComponent.SetAnimationMode(AnimationMode.Asset); MaterialInstanceDynamic prototypeMaterial = rightSkeletalMeshComponent.CreateAndSetMaterialInstanceDynamic(0); prototypeMaterial.SetVectorParameterValue("AccentColor", new(0.0f, 0.5f, 1.0f)); Assert.IsNotNull(prototypeMaterial.GetParent()); AnimationMontage rightPrototypeAnimationMontage = AnimationMontage.Load("/Game/Tests/Characters/Animations/RunAnimationMontage"); rightSkeletalMeshComponent.PlayAnimation(rightPrototypeAnimationMontage, true); AnimationInstance rightPrototypeAnimationInstance = rightSkeletalMeshComponent.GetAnimationInstance(); Assert.IsTrue(rightPrototypeAnimationInstance.IsPlaying(rightPrototypeAnimationMontage)); Assert.IsTrue(rightSkeletalMeshComponent.GetBoneName(0) == "root"); Bounds rightSkeletalMeshComponentBounds = default; rightSkeletalMeshComponent.GetBounds(rightSkeletalMeshComponent.GetTransform(), ref rightSkeletalMeshComponentBounds); Assert.IsFalse(rightSkeletalMeshComponentBounds == default(Bounds)); }
public Actor(ContentRegister content, Vector3 position, float animationSpeed, int animationIndex) { Matrix.CreateRotationZ(1 - (float)animationIndex, out this.worldMatrix); this.worldMatrix.Translation = position; model = new ModelInstance(); this.animationController = model.GetAnimationController(); content.Add(this); this.animation = this.animationController.PlayLoopingAnimation(animationIndex); this.animation.PlaybackSpeed = animationSpeed; }
public override void InitDeviceResources(GraphicsDevice device) { base.InitDeviceResources(device); _animators = new AnimatorList(StaticActor.Model); /// All animators in the stack should have the same set of animations. AnimationInstance animator = _animators.Sample; // TODO (****) Do we need this check??? if (animator.HasAnimation("full_running")) { // Add individual animations to blend controller. idleController = SimpleController.TryMake(animator, "full_running"); SetAnimation(idleController); } }
/// <summary> /// Initializes a new instance of the <see cref="FadeInAndReplaceTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <param name="fadeInDuration">The duration over which the new animation fades in.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="previousAnimation"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="fadeInDuration"/> is 0 or negative. /// </exception> public FadeInAndReplaceTransition(AnimationInstance previousAnimation, TimeSpan fadeInDuration) { if (previousAnimation == null) { throw new ArgumentNullException("previousAnimation"); } if (fadeInDuration <= TimeSpan.Zero) { throw new ArgumentOutOfRangeException("fadeInDuration", "The fade-in duration must be greater than 0."); } _previousAnimation = previousAnimation; _previousAnimationRunCount = previousAnimation.RunCount; _fadeInDuration = fadeInDuration; }
private void DrawBomb(Context context, Bomb bomb) { float drawX = bomb.GetPx(); float drawY = bomb.GetPy(); AnimationInstance anim = bomb.currentAnimation; anim.Draw(context, drawX, drawY + 0.5f * cellHeight, bomb.IsBlocked ? Color.Red : Color.White); if (CVars.g_drawBombDir.boolValue) { TextureImage dirImage = dirLookup[bomb.direction]; context.DrawImage(dirImage, drawX - 0.5f * dirImage.GetWidth(), drawY - 0.5f * dirImage.GetHeight()); } context.DrawRect(bomb.cx * cellWidth, bomb.cy * cellHeight, cellWidth, cellHeight, Color.White); context.DrawRect(bomb.px - 0.5f * cellWidth, bomb.py - 0.5f * cellHeight, cellWidth, cellHeight, Color.Red); }
private void DrawAnim(Context context, AnimationInstance instance, int x, int y) { int frameIndex = instance.FrameIndex; TextureImage texture = instance.Texture; Animation group = instance.Animation; Rectangle src; int ox = group.frames[frameIndex].ox; int oy = group.frames[frameIndex].oy; src.X = group.frames[frameIndex].x; src.Y = group.frames[frameIndex].y; src.Width = group.frames[frameIndex].w; src.Height = group.frames[frameIndex].h; context.DrawImagePart(texture, src, x - ox, y - oy); }
private void SetActiveAnimationState(AnimationState animationState, Random random) { if (animationState == null || animationState.Animations.Count == 0 || _activeModelDrawConditionState == null) { return; } if (_activeModelDrawConditionState.StillActive() == false) { _activeAnimationState = null; } else if (animationState == _activeAnimationState) { return; } _activeAnimationState = animationState; var modelInstance = _activeModelDrawConditionState.Model; modelInstance.AnimationInstances.Clear(); var animationBlock = animationState.Animations[random.Next(0, animationState.Animations.Count - 1)]; if (animationBlock != null) { foreach (var animation in animationBlock.Animations) { var anim = animation.Value; //Check if the animation does really exist if (anim != null) { var flags = animationState.Flags; var mode = animationBlock.AnimationMode; var animationInstance = new AnimationInstance(modelInstance, anim, mode, flags, GameObject); modelInstance.AnimationInstances.Add(animationInstance); animationInstance.Play(); break; } } } }
/// <summary> /// Load up our animations and bind to the given model. /// </summary> /// <param name="sro"></param> private void LoadAnimations(FBXModel sro) { Debug.Assert(SharedAnim != null, "Must set SharedAnim to class's shared animation in constructor."); if (SharedAnim.ActiveAnimator == null) { SharedAnim.ActiveAnimator = new AnimatorList(sro); } _animators = SharedAnim.ActiveAnimator; AnimatorList animList = SharedAnim.ActiveAnimator; AnimationInstance animator = animList.Sample; if (animator != null && animator.HasAnimation(SharedAnim.ActiveName)) { if (SharedAnim.ActiveController == null) { SharedAnim.ActiveController = SimpleController.TryMake(animator, SharedAnim.ActiveName); AnimActive(); } } else { animList.ApplyController(null); } if (SharedAnim.IdleAnimator == null) { SharedAnim.IdleAnimator = new AnimatorList(sro); AnimationInstance sharedIdle = SharedAnim.IdleAnimator.Sample; if ((sharedIdle != null) && sharedIdle.HasAnimation(SharedAnim.IdleName)) { SharedAnim.IdleController = SimpleController.TryMake( sharedIdle, SharedAnim.IdleName); } if (SharedAnim.IdleController != null) { AnimIdle(); } else { SharedAnim.IdleAnimator = null; } } }
protected void _InitAnimation(Animation data, ref AnimationInstance instance) { instance.Started = true; instance.Finished = false; // set parameter value -- note special case for vector2's instance.Parameter = Owner.Components.GetInterface<ValueInterface<float>>("float", data.ParameterName); if (instance.Parameter == null && data.ParameterName.EndsWith(".x", StringComparison.CurrentCultureIgnoreCase)) { String param = data.ParameterName.Substring(0, data.ParameterName.Length - 2); instance.ParameterX = Owner.Components.GetInterface<ValueInterface<Vector2>>("vector2", param); } else if (instance.Parameter == null && data.ParameterName.EndsWith(".y", StringComparison.CurrentCultureIgnoreCase)) { String param = data.ParameterName.Substring(0, data.ParameterName.Length - 2); instance.ParameterY = Owner.Components.GetInterface<ValueInterface<Vector2>>("vector2", param); } if (instance.Parameter == null && instance.ParameterX == null && instance.ParameterY == null) { instance.Finished = true; return; } if (instance.Scale == 0.0f) instance.Scale = 1.0f; if (data.RandomStart) { instance.Time = TorqueUtil.GetRandomFloat(data.Duration); if (data.PingPong && TorqueUtil.GetRandomFloat() < 0.5f) instance.Scale *= -1.0f; } else if (instance.Scale > 0.0f) instance.Time = 0.0f; else instance.Time = data.Duration; instance.Started = true; instance.Finished = false; instance.Paused = false; }
/// <summary> /// Combines the new animation with existing animations by inserting the new animation after the /// specified animation into the composition chains. The new animation takes effect immediately. /// </summary> /// <param name="previousAnimation"> /// The animation after which the new animation should be added. /// </param> /// <returns>The <see cref="AnimationTransition"/>.</returns> public static AnimationTransition Compose(AnimationInstance previousAnimation) { return new ComposeTransition(previousAnimation); }
/// <summary> /// Replaces the specified animation with the new animation. The new animation takes effect /// immediately. The previous animation is stopped and removed from the animation system. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> /// <returns>The <see cref="AnimationTransition"/>.</returns> public static AnimationTransition Replace(AnimationInstance previousAnimation) { return new ReplaceTransition(previousAnimation); }
/// <summary> /// Initializes a new instance of the <see cref="ComposeTransition"/> class. /// </summary> /// <param name="previousAnimation">The animation that should be replaced.</param> public ComposeTransition(AnimationInstance previousAnimation) { _previousAnimation = previousAnimation; }
private readonly int _id; // 0 indicates an invalid AnimationController. #endregion Fields #region Constructors //-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="AnimationController"/> struct. /// </summary> internal AnimationController(AnimationManager animationManager, AnimationInstance animationInstance) { Debug.Assert(animationManager != null, "The animation system is null."); Debug.Assert(animationInstance != null, "The animation instance is null."); Debug.Assert(animationInstance.RunCount > 0, "The animation instance has an invalid RunCount."); _id = animationInstance.RunCount; _animationManager = animationManager; _animationInstance = animationInstance; }
/// <summary> /// Throws an <see cref="InvalidOperationException"/>. /// </summary> /// <param name="index"> /// The zero-based index at which <paramref name="child"/> should be inserted. /// </param> /// <param name="child">The object to insert.</param> /// <exception cref="InvalidOperationException"> /// Cannot add animation instance. The current animation instance cannot have children. /// </exception> protected override void InsertItem(int index, AnimationInstance child) { throw new InvalidOperationException("Cannot add animation instance. The current animation instance cannot have children."); }