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;
    }

    /**
     * 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	/*
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	/**
42	* Sets a new default duration for fadeTo(), which will be used if no
43	* duration was passed to fadeTo() calls.
44	*
45	* @param defaultDuration - default duration for fadeTo() in seconds
46	*/
47	void setDefaultDuration(float defaultDuration) {
48	this->duration = defaultDuration;
49	}
50
51	/**
52	* Fade the current value in @duration seconds to the new value reflected
53	* by @a endValue, assuming the given @a sampleRate.
54	*/
55	void fadeTo(float endValue, float duration, float sampleRate) {
56	if (duration <= 0.f) {
57	setCurrentValue(endValue);
58	return;
59	}
60	this->endValue = endValue;
61	steps = duration * sampleRate;
62	c = M_PI / duration / sampleRate;
63	denormalizer = (value - endValue) * 0.5f;
64	offset = endValue + denormalizer;
65	real = 1;
66	imag = 0;
67	}
68
69	/**
70	* Fade the current value in the currently set default duration to the new
71	* value reflected by @a endValue, assuming the given @a sampleRate.
72	*/
73	void fadeTo(float endValue, float sampleRate) {
74	fadeTo(endValue, duration, sampleRate);
75	}
76
77	/**
78	* Proceed transition by exactly one sample point and return the current
79	* smoothed value at this stage.
80	*/
81	inline float render() {
82	if (!steps) return endValue;
83	--steps;
84	value = offset + real * denormalizer;
85	real -= c * imag;
86	imag += c * real;
87	return value;
88	}
89
90	protected:
91	int64_t steps;
92	float value;
93	float endValue;
94	float real;
95	float imag;
96	float c;
97	float denormalizer;
98	float offset;
99	float duration;
100	};
101
102	} // namespace LinuxSampler
103
104	#endif // LS_EASEINEASEOUT_H