public void Shake(float duration, float shakeTime, float power, ShakeDirection shakeDirection = ShakeDirection.AllDirections) { foreach (var _s in _sprites) { _s.Shake(duration, shakeTime, power, shakeDirection); } }
private void Update() { if (shakeCamera) { //Get current rotation values //float XRot = mainCamera.transform.rotation.x; //float YRot = mainCamera.transform.rotation.y; float ZRot = mainCamera.transform.rotation.z; //float WRot = mainCamera.transform.rotation.w; //Shake main camera //Order of Camera "Shake" operations (aka applying Z Rotation left and right) //1. Move Camera Z Rot to shakeZRotMin //2. Move Camera Z Rot to shakeZRotMax //3. At zero, increment currectShakeBounces //4. Repeat until currectShakeBounces == shakeBounces float RotStep; if (currentShakeDirection == ShakeDirection.RIGHT) { RotStep = rotationStep * -1; } else { RotStep = rotationStep; } mainCamera.transform.Rotate(new Vector3(0f, 0f, RotStep)); //mainCamera.transform.rotation.SetFromToRotation(mainCamera.transform.rotation,); ZRot = mainCamera.transform.rotation.z; if (ZRot <= -5) { currentShakeDirection = ShakeDirection.LEFT; } if (ZRot >= 5) { currentShakeDirection = ShakeDirection.RIGHT; } if (ZRot == 0.0f) { currectShakeBounces++; } if (currectShakeBounces == shakeBounces) { shakeCamera = false; } } }
// This is a either or question, calling it once with x and then with y will only do y scaling public void Scale(float factor, ShakeDirection dir = ShakeDirection.AllDirections) { if (dir == ShakeDirection.AllDirections) { _sprite.Scale = new Vector2f(factor * _scaleVector.X, factor * _scaleVector.X); } else if (dir == ShakeDirection.UpDown) { _sprite.Scale = new Vector2f(_scaleVector.X, factor * _scaleVector.X); } else if (dir == ShakeDirection.LeftRight) { _sprite.Scale = new Vector2f(factor * _scaleVector.X, _scaleVector.X); } }
/// <summary> /// currently buggy /// </summary> /// <param name="duration"></param> /// <param name="shakeTime"></param> /// <param name="power"></param> /// <param name="shakeDirection"></param> public void Shake(float duration, float shakeTime, float power, ShakeDirection shakeDirection = ShakeDirection.AllDirections) { if (duration < 0.0f) { throw new ArgumentOutOfRangeException("duration", duration, "Duration for a shake must be non-negative"); } if (shakeTime < 0.0f) { throw new ArgumentOutOfRangeException("shakeTime", shakeTime, "Time for a shake must be non-negative"); } _shakePower = power; _shakeTimer = 0.0f; _shakeTimerMax = shakeTime; _shakeDirection = shakeDirection; }
/// <summary> /// Adds a shake to the camera. If the previous shaking is not complete, the remaining strength /// will combine with the new one. /// </summary> /// <param name="direction">The direction of the shake.</param> /// <param name="strength"> /// The strength of the shake, or how many pixels it will move at most in one direction (assuming /// the shake function stays in its default range of [-1, 1]). Defaults to 10. /// </param> /// <param name="time">How long, in seconds, the shake should last. Defaults to .5.</param> /// <param name="speed">The speed of the shake. The lower, the less the camera will shake. Defaults to 100.</param> public void Shake(ShakeDirection direction = ShakeDirection.Horizontal, uint strength = 10, float time = .5f, uint speed = 100) { switch (direction) { case ShakeDirection.Horizontal: Shake(t => new Vector2(MathF.Cos(t), 0), strength, time, speed); break; case ShakeDirection.Vertical: Shake(t => new Vector2(0, MathF.Cos(t)), strength, time, speed); break; case ShakeDirection.Circular: Shake(t => new Vector2(MathF.Sin(t), MathF.Cos(t)), strength, time, speed); break; default: throw new ArgumentOutOfRangeException("Unexpected case"); } }
/// <summary> /// Start the Effect and Call DoStartEffect /// </summary> /// <param name="duration"></param> /// <param name="inverseFrequency"></param> /// <param name="col"></param> /// <param name="power"></param> /// <param name="shakeDirection"></param> public void StartEffect(float duration, float inverseFrequency, Color col, float power, ShakeDirection direction = ShakeDirection.AllDirections) { if ((duration < 0.0f) && (duration != -1.0f)) { throw new ArgumentOutOfRangeException("duration", duration, "Duration for a screen effect must be non-negative or -1.0f "); } if (inverseFrequency < 0.0f) { throw new ArgumentOutOfRangeException("shakeTime", inverseFrequency, "Time for a shake must be non-negative"); } EffectTotalTime = EffectRemainingTime = duration; _inverseFrequency = _inverseFrequencyTotal = inverseFrequency; _color = col; _initialAlpha = _color.A; _power = power; _direction = direction; IsEffectActive = true; DoStartEffect(); }
/// <summary> /// Give the camera a shaking effect. /// </summary> /// <param name="intensity">The amount of camera shake.</param> /// <param name="duration">The duration of the camera shake, in seconds.</param> /// <param name="decreasing">Whether the shake intensity will decrease over time or not.</param> /// <param name="forceReset">A flag used to determine if the shake will reset any current camera shake.</param> /// <param name="callback">The method that will be invoked after the camera shake has finished.</param> /// <param name="direction">The direction of the camera shake.</param> public void Shake(float intensity = 5f, float duration = 1f, bool decreasing = false, bool forceReset = false, Action callback = null, ShakeDirection direction = ShakeDirection.Both) { // Apply the shake if the camera is not already shaking, unless force reset is true. if (!_shakeTimer.IsRunning || forceReset) { _shakeIntensity = intensity; _shakeDecreasing = decreasing; _shakeDirection = direction; _shakeTimer.Duration = duration; _shakeTimer.Callback = callback; _shakeTimer.Start(true); } }
public static void CreateLinearGlowInOut(out Texture targetTexture, uint sizeX, uint sizeY, Color col, float opacity = 0.2f, PennerDoubleAnimation.EquationType type = PennerDoubleAnimation.EquationType.Linear, ShakeDirection direction = ShakeDirection.UpDown) { Image targetImage = new Image(sizeX, sizeY); float centerPosition = 0.0f; if (direction == ShakeDirection.UpDown) { centerPosition = sizeY / 2.0f; } else if (direction == ShakeDirection.LeftRight) { centerPosition = sizeX / 2.0f; } for (uint i = 0; i != sizeX; i++) { for (uint j = 0; j != sizeY; j++) { Color pixelCol = col; float distanceToCenter = 0.0f; if (direction == ShakeDirection.UpDown) { distanceToCenter = (float)Math.Abs(centerPosition - j); } else if (direction == ShakeDirection.LeftRight) { distanceToCenter = (float)Math.Abs(centerPosition - i); } float newAlpha = 255.0f * opacity * (1.0f - (float)PennerDoubleAnimation.GetValue(type, distanceToCenter, 0, 1, centerPosition)); if (newAlpha < 0.0f) { newAlpha = 0.0f; } //Console.WriteLine(newAlpha); pixelCol.A = (byte)newAlpha; targetImage.SetPixel(i, j, pixelCol); } } targetTexture = new Texture(targetImage); }