C# Particle.ApplyForce方法代码示例

        /// <summary>
        /// Processes the specified Particle.
        /// </summary>
        public override void Process(float totalSeconds, float elapsedSeconds, ref Particle particle, object tag)
        {
            Vector2 deltaGrav;

            Vector2.Multiply(ref this.Gravity, elapsedSeconds, out deltaGrav);

            particle.ApplyForce(ref deltaGrav);
        }

        private float _strength;    //Gravity strength in pixels per second.

        /// <summary>
        /// Processes an active particle.
        /// </summary>
        /// <param name="totalTime">Total game time in whole and fractional seconds.</param>
        /// <param name="elapsedTime">Elapsed game time in whole and fractional seconds.</param>
        /// <param name="particle">The particle to be updated.</param>
        /// <param name="age">The age of the particle in the range of zero to one inclusive.</param>
        public override void ProcessActiveParticle(float totalTime, float elapsedTime, ref Particle particle, float age)
        {
            Vector2 force = this._gravity;

            Vector2.Multiply(ref force, this._strength * elapsedTime, out force);

            particle.ApplyForce(ref force);
        }

        private float _coefficient;     //The damping coefficient.

        /// <summary>
        /// Processes an active particle.
        /// </summary>
        /// <param name="totalTime">Total game time in whole and fractional seconds.</param>
        /// <param name="elapsedTime">Elapsed game time in whole and fractional seconds.</param>
        /// <param name="particle">The particle to be processed.</param>
        /// <param name="age">The age of the particle in the range 0-1.</param>
        public override void ProcessActiveParticle(float totalTime, float elapsedTime, ref Particle particle, float age)
        {
            Vector2 momentum = particle.Momentum;

            Vector2.Multiply(ref momentum, this._coefficient, out momentum);

            Vector2.Negate(ref momentum, out momentum);

            particle.ApplyForce(ref momentum);
        }

        /// <summary>
        /// Processes the specified Particle.
        /// </summary>
        public override void Process(float totalSeconds, float elapsedSeconds, ref Particle particle, object tag)
        {
            Vector2 distance;

            // Calculate the distance between the Particle and the gravity well...
            Vector2.Subtract(ref this.Position, ref particle.Position, out distance);

            // Check to see if the Particle is within range of the gravity well...
            if (distance.LengthSquared() < this.RadiusSquared)
            {
                Vector2 force;

                // We can re-use the distance vector, and normalise it as the force vector...
                Vector2.Normalize(ref distance, out force);

                // Adjust the force vector based on the strength of the gravity well and the time delta...
                Vector2.Multiply(ref force, this.Strength * elapsedSeconds, out force);

                particle.ApplyForce(ref force);
            }
        }

        /// <summary>
        /// When overridden in the derived class, handles processing the <paramref name="particle"/> when
        /// it is updated. Only valid if <see cref="ParticleModifier.ProcessOnUpdate"/> is set.
        /// </summary>
        /// <param name="emitter">The <see cref="ParticleEmitter"/> that the <paramref name="particle"/>
        /// came from.</param>
        /// <param name="particle">The <see cref="Particle"/> to process.</param>
        /// <param name="elapsedTime">The amount of time that has elapsed since the <paramref name="emitter"/>
        /// was last updated.</param>
        protected override void HandleProcessUpdated(ParticleEmitter emitter, Particle particle, int elapsedTime)
        {
            // Get the absolute position
            Vector2 absolutePosition;
            emitter.GetAbsoultePosition(ref _position, out absolutePosition);

            // Get the distance from the particle
            Vector2 distance;
            Vector2.Subtract(ref absolutePosition, ref particle.Position, out distance);

            // Check if the particle is in range
            if (distance.LengthSquared() >= _radiusSquared)
                return;

            // Normalize the distance vector to get the force
            Vector2 force;
            Vector2.Normalize(ref distance, out force);

            // Adjust the force by the strength and elapsed time
            Vector2.Multiply(ref force, _strength * elapsedTime, out force);

            // Apply the force to the particle
            particle.ApplyForce(ref force);
        }

        /// <summary>
        /// Processes an active particle.
        /// </summary>
        /// <param name="totalTime">Total game time in whole and fractional seconds.</param>
        /// <param name="elapsedTime">Elapsed game time in whole and fractional seconds.</param>
        /// <param name="particle">The particle which is ready to be processed.</param>
        /// <param name="age">The age of the particle in the range 0-1.</param>
        public override void ProcessActiveParticle(float totalTime, float elapsedTime, ref Particle particle, float age)
        {
            float distance;

            Vector2.DistanceSquared(ref this._position, ref particle.Position, out distance);

            if (distance < this._radiusSq)
            {
                float effect = 1f - (distance / this._radiusSq);

                Vector2 force;

                Vector2.Subtract(ref this._position, ref particle.Position, out force);

                Vector2.Normalize(ref force, out force);

                Vector2.Transform(ref force, ref this._rotation, out force);

                Vector2.Multiply(ref force, effect * elapsedTime * this._vorticity, out force);

                particle.ApplyForce(ref force);
            }
        }