public void PlayAnimation(string animDict, string animName, float blendInSpeed, float blendOutSpeed, int duration, AnimationFlags flags, float playbackRate) { InputArgument[] arguments = new InputArgument[] { animDict }; Function.Call(Hash.REQUEST_ANIM_DICT, arguments); DateTime time = DateTime.UtcNow + new TimeSpan(0, 0, 0, 0, 0x3e8); while (true) { InputArgument[] argumentArray2 = new InputArgument[] { animDict }; if (Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, argumentArray2)) { InputArgument[] argumentArray3 = new InputArgument[11]; argumentArray3[0] = this._ped.Handle; argumentArray3[1] = animDict; argumentArray3[2] = animName; argumentArray3[3] = blendInSpeed; argumentArray3[4] = blendOutSpeed; argumentArray3[5] = duration; argumentArray3[6] = flags; argumentArray3[7] = playbackRate; argumentArray3[8] = 0; argumentArray3[9] = 0; argumentArray3[10] = 0; Function.Call(Hash.TASK_PLAY_ANIM, argumentArray3); return; } Script.Yield(); if (DateTime.UtcNow >= time) { return; } } }
private void ForceCarryAnimation() { /* A somewhat fix to the force play door opening animation */ AnimationFlags flags = AnimationFlags.UpperBodyOnly | AnimationFlags.Loop | AnimationFlags.AllowRotation | AnimationFlags.StayInEndFrame | (AnimationFlags)2; Game.PlayerPed.Task.PlayAnimation("anim@heists@box_carry@", "walk", 18.0f, -1, flags); }
public Animation(float timePerFrame, int[] indices, AnimationFlags flags) : this() { this.TimePerFrame = timePerFrame; this.Flags = flags; this.Indices.AddRange(indices); }
/// <summary> /// Zwraca odpowiednią flagę animacji. /// </summary> /// <param name="animData"></param> /// <returns></returns> public static int BuildAnimationFlags(Animation animData) { AnimationFlags output = AnimationFlags.None; if (animData.Loop) { output = output | AnimationFlags.Loop; } if (animData.StopOnLastFrame) { output = output | AnimationFlags.StopOnLastFrame; } if (animData.OnlyAnimateUpperBody) { output = output | AnimationFlags.OnlyAnimateUpperBody; } if (animData.AllowPlayerControl) { output = output | AnimationFlags.AllowPlayerControl; } if (animData.Cancellable) { output = output | AnimationFlags.Cancellable; } return((int)output); }
public Animations(string animDict, string animName, float blendSpeed = 3f, AnimationFlags flag = 0) { AnimationDictionary = animDict; AnimationName = animName; BlendInSpeed = blendSpeed; AnimationFlag = flag; }
internal void RefreshMenu() { AnimationFlags flags = AnimationFlags.Activate | AnimationFlags.Slide; bool isRTL = CultureInfo.CurrentUICulture.TextInfo.IsRightToLeft; if (isRTL) { OpenFlags = flags | AnimationFlags.Right; } else { OpenFlags = flags | AnimationFlags.Left; } //--- flags = AnimationFlags.Hide | AnimationFlags.Slide; if (isRTL) { CloseFlags = flags | AnimationFlags.Left; } else { CloseFlags = flags | AnimationFlags.Right; } }
public AnimationInstance(ModelInstance modelInstance, W3DAnimation animation, AnimationMode mode, AnimationFlags flags) { _animation = animation; _mode = mode; _flags = flags; _boneInstances = modelInstance.ModelBoneInstances; _keyframeIndices = new int[animation.Clips.Length]; if (_flags.HasFlag(AnimationFlags.StartFrameFirst) || _flags == AnimationFlags.None) { _currentTimeValue = TimeSpan.Zero; } else if (_flags.HasFlag(AnimationFlags.StartFrameLast)) { _currentTimeValue = _animation.Duration; } else { //TODO: implement other flags //throw new NotImplementedException(); } }
private void PopulateAnimations(SpriteDataContent Sprite, SpriteHeader Header, IEnumerable <string> AnimationRows) { List <SpriteAnimationDataContent> Animations = new List <SpriteAnimationDataContent>(); foreach (var AnimationRow in AnimationRows) { var Reader = CreateReader(AnimationRow); string AnimationName = Reader.Read(); float Duration = float.Parse(Reader.Read()); var Frames = ParseFrames(Header, Reader).ToArray(); // Array to process entirely so we do Reader.Read at right times. AnimationFlags Flags = AnimationFlags.None; while (Reader.HasMore()) { string NextFlag = Reader.Read(); AnimationFlags Flag = (AnimationFlags)Enum.Parse(typeof(AnimationFlags), NextFlag); Flags |= Flag; } var FrameNames = Frames.Select(IndexToName); Dictionary <string, TimeSpan> FrameDurations = new Dictionary <string, TimeSpan>(); foreach (var FrameName in FrameNames) { FrameDurations.Add(FrameName, TimeSpan.FromMilliseconds(Duration)); } SpriteAnimationDataContent Animation = new SpriteAnimationDataContent() { FrameDurations = FrameDurations, IsDefault = (Flags & AnimationFlags.Default) != 0, IsLooped = (Flags & AnimationFlags.Looped) != 0, Name = AnimationName }; Animations.Add(Animation); } Sprite.Animations = Animations; }
public AnimationFlags Load(string path, string name) { var cacheKey = $"{path}/{name}"; if (_cache.ContainsKey(cacheKey)) { return(_cache[cacheKey]); } foreach (var config in _settings) { var flags = config.Load(path, name); if (flags != null) { _cache[cacheKey] = flags; return(flags); } } lock (locker) { var flags = new AnimationFlags(); _cache[cacheKey] = flags; _dumpSetting.Save(path, name, flags); return(flags); } }
public Animations(string scenarioName, string animationName, float blendSpeed = 3f, AnimationFlags flag = AnimationFlags.None) { ScenarioName = scenarioName; FirstAnimation = animationName; BlendInSpeed = blendSpeed; AnimationFlag = flag; }
internal static void AnimateWindow(Control control, int time, AnimationFlags flags) { try { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); sp.Demand(); AnimateWindow(new HandleRef(control, control.Handle), time, flags); } catch (SecurityException) { } }
public Animation(float timePerFrame, int[] indices, AnimationFlags flags) : this() { this.TimePerFrame = timePerFrame; this.Flags = flags; this.Indices.AddRange(indices); }
public Animation(string name, float framesPerSecond, AnimationFlags animationFlag = AnimationFlags.None, SpriteEffects flipEffect = SpriteEffects.None, float rotation = 0f) : this(name, framesPerSecond) { FlipEffect = flipEffect; AnimationFlag = animationFlag; Rotation = rotation; }
public Animation(EMSAnimation type, string dict, string name, int time, AnimationFlags flags) { AnimationType = type; ShortName = type.ToString(); Dictionary = dict; AnimationName = name; AnimationTime = time; Flags = flags; }
protected override void OnVisibleChanged(EventArgs e) { base.OnVisibleChanged(e); if ((Visible && PopupAnimation == PopupAnimations.None) || (!Visible && CloseAnimation == PopupAnimations.None)) { return; } AnimationFlags flags = Visible ? AnimationFlags.Roll : AnimationFlags.Hide; PopupAnimations _flags = Visible ? PopupAnimation : CloseAnimation; if (_flags == PopupAnimations.SystemDefault) { if (SystemInformation.IsMenuAnimationEnabled) { if (SystemInformation.IsMenuFadeEnabled) { _flags = PopupAnimations.Blend; } else { _flags = PopupAnimations.Slide | (Visible ? PopupAnimations.TopToBottom : PopupAnimations.BottomToTop); } } else { _flags = PopupAnimations.None; } } if ((_flags & (PopupAnimations.Blend | PopupAnimations.Center | PopupAnimations.Roll | PopupAnimations.Slide)) == PopupAnimations.None) { return; } if (_resizableTop) // popup is “inverted”, so the animation must be { if ((_flags & PopupAnimations.BottomToTop) != PopupAnimations.None) { _flags = (_flags & ~PopupAnimations.BottomToTop) | PopupAnimations.TopToBottom; } else if ((_flags & PopupAnimations.TopToBottom) != PopupAnimations.None) { _flags = (_flags & ~PopupAnimations.TopToBottom) | PopupAnimations.BottomToTop; } } if (_resizableLeft) // popup is “inverted”, so the animation must be { if ((_flags & PopupAnimations.RightToLeft) != PopupAnimations.None) { _flags = (_flags & ~PopupAnimations.RightToLeft) | PopupAnimations.LeftToRight; } else if ((_flags & PopupAnimations.LeftToRight) != PopupAnimations.None) { _flags = (_flags & ~PopupAnimations.LeftToRight) | PopupAnimations.RightToLeft; } } flags |= (AnimationFlags.Mask & (AnimationFlags)(int)_flags); NativeUtility.AnimateWindow(this, AnimationDuration, flags); }
public AnimationInstance(ModelInstance modelInstance, W3DAnimation animation, AnimationMode mode, AnimationFlags flags, GameObject gameObject) { _gameObject = gameObject; _animation = animation; _mode = mode; _flags = flags; _boneInstances = modelInstance.ModelBoneInstances; _keyframeIndices = new int[animation.Clips.Length]; }
public ISerializable Deserialize(BinaryInput input) { Name = input.ReadString(); TimePerFrame = input.ReadSingle(); Frames = input.ReadList<KeyFrame>(); AnimationFlag = (AnimationFlags) input.ReadByte(); FlipEffect = (SpriteEffects) input.ReadByte(); Rotation = input.ReadSingle(); return this; }
public FoodInventoryItem(int amount, int maxAmount, string id, string description, string animationDict, string animationName, AnimationFlags animationFlags, int animationDuration, FoodType foodType, float restorationAmount) : base(amount, maxAmount, id, description) { AnimationDict = animationDict; AnimationName = animationName; AnimationFlags = animationFlags; AnimationDuration = animationDuration; FoodType = foodType; RestorationAmount = restorationAmount; }
internal static void AnimateWindow(Control control, int time, AnimationFlags flags) { try { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); sp.Demand(); AnimateWindow(new HandleRef(control, control.Handle), time, flags); } catch (SecurityException) { } }
public void PlayAnimation(string dictionary, string name, float speed = 8, AnimationFlags flags = (AnimationFlags)0) { Contract.NotEmpty(dictionary, nameof(dictionary)); Contract.NotEmpty(name, nameof(name)); CheckExistence(); using (var converter = new StringConverter()) { Rage.Player.Player_PlayAnimation(NativePointer, converter.StringToPointer(dictionary), converter.StringToPointer(name), speed, (int)flags); } }
/// <summary> /// Construct a new <see cref="AnimationInstance"/> /// </summary> /// <param name="modelBoneInstances">The bone instances to use, which will be modified as the animation plays</param> /// <param name="animation">The animation to apply to the bones</param> /// <param name="mode">The animation mode</param> /// <param name="flags">Additional animation flags</param> /// <param name="gameObject"></param> /// <param name="random">Random number generator used when combined with <see cref="AnimationFlags.RandomStart"/></param> public AnimationInstance(ModelBoneInstance[] modelBoneInstances, W3DAnimation animation, AnimationMode mode, AnimationFlags flags, GameObject gameObject, Random random) { _animation = animation; _mode = mode; _flags = flags; _boneInstances = modelBoneInstances; _keyframeIndices = new int[animation.Clips.Length]; _gameObject = gameObject; _random = random; }
internal static void AnimateWindow(Control control, int time, AnimationFlags flags) { Contract.Requires<ArgumentNullException>(control != null); try { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); sp.Demand(); AnimateWindow(new HandleRef(control, control.Handle), time, flags); } catch (SecurityException) { } }
private async Task GetPlayerPropsForDelivery(DeliveryType aDeliveryType) { if (aDeliveryType == DeliveryType.Scooter) { CitizenFX.Core.Debug.WriteLine(" :: Getting Player props for delivery."); if (aDeliveryType == DeliveryType.Scooter) { if (!HasModelLoaded((uint)GetHashKey("prop_paper_bag_01"))) { RequestModel((uint)GetHashKey("prop_paper_bag_01")); while (!HasModelLoaded((uint)GetHashKey("prop_paper_bag_01"))) { await Delay(0); } } Prop prop_ent = null; prop_ent = await World.CreateProp("prop_paper_bag_01", Game.PlayerPed.Position, Vector3.Zero, true, false); AttachEntityToEntity(prop_ent.Handle, Game.PlayerPed.Handle, GetPedBoneIndex(Game.PlayerPed.Handle, 28422), 0.25f, 0.0f, 0.06f, 65.0f, -130.0f, -65.0f, true, true, false, true, 0, true); m_player_attatchments.Add(prop_ent); } } if (aDeliveryType == DeliveryType.Van) { AnimationFlags flags = AnimationFlags.UpperBodyOnly | AnimationFlags.Loop | AnimationFlags.AllowRotation | AnimationFlags.StayInEndFrame | (AnimationFlags)2; Game.PlayerPed.Task.PlayAnimation("anim@heists@box_carry@", "walk", 18.0f, -1, flags); Prop prop_ent = null; var rs = GetRandomFromRange(0, DeliveryData.VAN_GOODS_PROP_NAMES.Count - 1); prop_ent = await World.CreateProp(DeliveryData.VAN_GOODS_PROP_NAMES[rs], GetOffsetFromEntityInWorldCoords(Game.PlayerPed.Handle, 0.0f, 0.0f, -5.0f), Vector3.Zero, false, false); AttachEntityToEntity(prop_ent.Handle, Game.PlayerPed.Handle, GetPedBoneIndex(Game.PlayerPed.Handle, 28422), 0.0f, 0.0f, -0.55f, 0.0f, 0.0f, 90.0f, true, false, false, true, 1, true); m_player_attatchments.Add(prop_ent); } if (aDeliveryType == DeliveryType.Truck) { AnimationFlags flags = AnimationFlags.UpperBodyOnly | AnimationFlags.Loop | AnimationFlags.AllowRotation | AnimationFlags.StayInEndFrame | (AnimationFlags)3; Game.PlayerPed.Task.PlayAnimation("anim@heists@box_carry@", "idle", 18.0f, -1, flags); Prop prop_ent = null; prop_ent = await World.CreateProp("prop_sacktruck_02b", GetOffsetFromEntityInWorldCoords(Game.PlayerPed.Handle, 0.0f, 0.0f, -5.0f), Vector3.Zero, false, false); AttachEntityToEntity(prop_ent.Handle, Game.PlayerPed.Handle, GetEntityBoneIndexByName(Game.PlayerPed.Handle, "SKEL_Pelvis"), -0.075f, 0.90f, -0.86f, -20.0f, 0.5f, 181.0f, true, false, false, true, 1, true); m_player_attatchments.Add(prop_ent); } }
internal static void AnimateWindow(Control control, int time, AnimationFlags flags) { Contract.Requires <ArgumentNullException>(control != null); try { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); sp.Demand(); AnimateWindow(new HandleRef(control, control.Handle), time, flags); } catch (SecurityException) { } }
public static void PlayKneelAnim(int duration) { if (!API.DoesEntityExist(API.GetPlayerPed(API.PlayerId()))) { return; } if (API.IsPedArmed(API.GetPlayerPed(API.PlayerId()), 7)) { API.SetCurrentPedWeapon(API.GetPlayerPed(API.PlayerId()), 0xA2719263, true); } AnimationFlags flags = AnimationFlags.None; Game.PlayerPed.Task.PlayAnimation("amb@medic@standing@kneel@idle_a", "idle_a", 10, duration, flags); }
internal static void AnimateWindow(Control control, int time, AnimationFlags flags) { if (control == null) { throw new ArgumentNullException(nameof(control), "Contract assertion not met: control != null"); } try { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); sp.Demand(); AnimateWindow(new HandleRef(control, control.Handle), time, flags); } catch (SecurityException) { } }
/// <summary> /// Plays a specific animation and waits until this animation is over. /// </summary> /// <param name="animDict">The animation dictionary to use.</param> /// <param name="animName">The name of the animation to use.</param> /// <param name="animFlags">The flags to apply to the animation.</param> public static void PlayAnimationAndWait(string animDict, string animName, AnimationFlags animFlags) { Ped ped = Game.Player.Character; Function.Call(Hash.REQUEST_ANIM_DICT, animDict); while (!Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, animDict)) { Script.Yield(); } Game.Player.Character.Task.PlayAnimation(animDict, animName, 8f, -8f, -1, animFlags, 0f); while (Function.Call <float>(Hash.GET_ENTITY_ANIM_CURRENT_TIME, ped, animDict, animName) < 0.9f) { Script.Yield(); } }
public void Save(string path, string name, AnimationFlags flags) { lock (locker) { foreach (var config in _settings) { var existing = config.Load(path, name); if (existing != null) { config.Save(path, name, flags); return; } } _cache.Clear(); _defaultSetting.Save(path, name, flags); _dumpSetting.Delete(path, name); } }
public void PlayAnimation(string animDict, string animName, float blendInSpeed, float blendOutSpeed, int duration, AnimationFlags flags, float playbackRate, float timeout = 1000f) { if (!Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, animDict)) { Function.Call(Hash.REQUEST_ANIM_DICT, animDict); } var end = DateTime.UtcNow.AddMilliseconds(timeout); while (!Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, animDict)) { if (DateTime.UtcNow >= end) { return; } } Function.Call(Hash.TASK_PLAY_ANIM, _ped.Handle, animDict, animName, blendInSpeed, blendOutSpeed, duration, (int)flags, playbackRate, false, false, false); }
/// <summary> /// Plays a raw animation. /// </summary> /// <param name="animationName">Name of the animation we wish to play</param> /// <param name="flags"></param> /// <param name="slot">Slot on which to play the animation</param> /// <param name="layer">Animation layer to play the animation in.</param> /// <param name="blend">Transition time between two animations.</param> /// <param name="speed">Animation playback speed</param> public void PlayAnimation(string animationName, AnimationFlags flags = 0, int slot = 0, int layer = 0, float blend = 0.175f, float speed = 1.0f) { NativeEntityMethods.PlayAnimation(this.GetIEntity(), animationName, slot, layer, blend, speed, flags); }
private static extern int AnimateWindow(HandleRef windowHandle, int time, AnimationFlags flags);
public static async Task AnimatePlayer(string dict, string animation, AnimationFlags anim_flags) { await RequestAnimationDictionary(dict); PlayAnimation(dict, animation, anim_flags); }
public static void PlayAnimation(string dict, string animation, AnimationFlags anim_flags) { Game.PlayerPed.Task.ClearAll(); Game.PlayerPed.Task.PlayAnimation(dict, animation, -1, -1, anim_flags); }
public static void PlayEntityAnim(Entity entity, AnimationDictionary animDict, string animName, bool loop, AnimationFlags flags = AnimationFlags.None) { animDict.LoadAndWait(); NativeFunction.CallByName <uint>("PLAY_ENTITY_ANIM", entity, animName, animDict.Name, 1000f, loop, 1, 0, 0f, (uint)flags); }
public bool HasFlag(AnimationFlags flags) { return((this.flags & (ushort)flags) == (ushort)flags); }
private static extern int AnimateWindow(HandleRef windowHandle, int time, AnimationFlags flags);
/// <summary> /// Plays a raw animation. /// </summary> /// <param name="animationName">Name of the animation we wish to play</param> /// <param name="flags"></param> /// <param name="slot">Slot on which to play the animation</param> /// <param name="layer">Animation layer to play the animation in.</param> /// <param name="blend">Transition time between two animations.</param> /// <param name="speed">Animation playback speed</param> public void PlayAnimation(string animationName, AnimationFlags flags = 0, int slot = 0, int layer = 0, float blend = 0.175f, float speed = 1.0f) { NativeEntityMethods.PlayAnimation(this.GetIEntity(), animationName, slot, layer, blend, speed, flags); }
public static void AnimateWindow(Control control, int time, AnimationFlags flags) { User32.AnimateWindow(new HandleRef(control, control.Handle), time, flags); }
internal static extern void PlayAnimation(IntPtr ptr, string animationName, int slot, int layer, float blend, float speed, AnimationFlags flags);