engines/common/EaseInEaseOut.h

/*
 * Copyright (c) 2017 Christian Schoenebeck
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

#ifndef LS_EASEINEASEOUT_H
#define LS_EASEINEASEOUT_H

#include <stdint.h>

namespace LinuxSampler {

/** @brief Value transition with ease-in and ease-out (sinusoidial) curve.
 *
 * Implements a smoothed transition from one value to another value in a
 * requested amount of time with an ease-in and ease-out algorithm,
 * based on a sinusoidial shaped curve.
 */
class EaseInEaseOut {
public:
    EaseInEaseOut() {
        steps = 0;
        value = 1.f;
        endValue = 1.f;
        duration = 1.f;
    }

    /**
     * Set the current value @b immediately to the given value.
     */
    void setCurrentValue(float value) {
        this->value = value;
        endValue = value;
        steps = 0;
    }

    inline float currentValue() const {
        return value;
    }

    /**
     * Sets a new default duration for fadeTo(), which will be used if no
     * duration was passed to fadeTo() calls.
     *
     * @param defaultDuration - default duration for fadeTo() in seconds
     */
    void setDefaultDuration(float defaultDuration) {
        this->duration = defaultDuration;
    }

    /**
     * Fade the current value in @duration seconds to the new value reflected
     * by @a endValue, assuming the given @a sampleRate.
     */
    void fadeTo(float endValue, float duration, float sampleRate) {
        if (duration <= 0.f) {
            setCurrentValue(endValue);
            return;
        }
        this->endValue = endValue;
        steps = duration * sampleRate;
        c = M_PI / duration / sampleRate;
        denormalizer = (value - endValue) * 0.5f;
        offset = endValue + denormalizer;
        real = 1;
        imag = 0;
    }

    /**
     * Fade the current value in the currently set default duration to the new
     * value reflected by @a endValue, assuming the given @a sampleRate.
     */
    void fadeTo(float endValue, float sampleRate) {
        fadeTo(endValue, duration, sampleRate);
    }

    /**
     * Proceed transition by exactly one sample point and return the current
     * smoothed value at this stage.
     */
    inline float render() {
        if (!steps) return endValue;
        --steps;
        value = offset + real * denormalizer;
        real -= c * imag;
        imag += c * real;
        return value;
    }

protected:
    int64_t steps;
    float value;
    float endValue;
    float real;
    float imag;
    float c;
    float denormalizer;
    float offset;
    float duration;
};

} // namespace LinuxSampler

#endif // LS_EASEINEASEOUT_H
1	schoenebeck	3188	/*
2			* Copyright (c) 2017 Christian Schoenebeck
3			*
4			* http://www.linuxsampler.org
5			*
6			* This file is part of LinuxSampler and released under the same terms.
7			* See README file for details.
8			*/
9
10			#ifndef LS_EASEINEASEOUT_H
11			#define LS_EASEINEASEOUT_H
12
13			#include <stdint.h>
14
15			namespace LinuxSampler {
16
17			/** @brief Value transition with ease-in and ease-out (sinusoidial) curve.
18			*
19			* Implements a smoothed transition from one value to another value in a
20			* requested amount of time with an ease-in and ease-out algorithm,
21			* based on a sinusoidial shaped curve.
22			*/
23			class EaseInEaseOut {
24			public:
25			EaseInEaseOut() {
26			steps = 0;
27			value = 1.f;
28			endValue = 1.f;
29			duration = 1.f;
30			}
31
32			/**
33			* Set the current value @b immediately to the given value.
34			*/
35			void setCurrentValue(float value) {
36			this->value = value;
37			endValue = value;
38			steps = 0;
39			}
40
41	schoenebeck	3335	inline float currentValue() const {
42			return value;
43			}
44
45	schoenebeck	3188	/**
46			* Sets a new default duration for fadeTo(), which will be used if no
47			* duration was passed to fadeTo() calls.
48			*
49			* @param defaultDuration - default duration for fadeTo() in seconds
50			*/
51			void setDefaultDuration(float defaultDuration) {
52			this->duration = defaultDuration;
53			}
54
55			/**
56			* Fade the current value in @duration seconds to the new value reflected
57			* by @a endValue, assuming the given @a sampleRate.
58			*/
59			void fadeTo(float endValue, float duration, float sampleRate) {
60			if (duration <= 0.f) {
61			setCurrentValue(endValue);
62			return;
63			}
64			this->endValue = endValue;
65			steps = duration * sampleRate;
66			c = M_PI / duration / sampleRate;
67			denormalizer = (value - endValue) * 0.5f;
68			offset = endValue + denormalizer;
69			real = 1;
70			imag = 0;
71			}
72
73			/**
74			* Fade the current value in the currently set default duration to the new
75			* value reflected by @a endValue, assuming the given @a sampleRate.
76			*/
77			void fadeTo(float endValue, float sampleRate) {
78			fadeTo(endValue, duration, sampleRate);
79			}
80
81			/**
82			* Proceed transition by exactly one sample point and return the current
83			* smoothed value at this stage.
84			*/
85			inline float render() {
86			if (!steps) return endValue;
87			--steps;
88			value = offset + real * denormalizer;
89			real -= c * imag;
90			imag += c * real;
91			return value;
92			}
93
94	schoenebeck	3246	protected:
95	schoenebeck	3188	int64_t steps;
96			float value;
97			float endValue;
98			float real;
99			float imag;
100			float c;
101			float denormalizer;
102			float offset;
103			float duration;
104			};
105
106			} // namespace LinuxSampler
107
108			#endif // LS_EASEINEASEOUT_H