engines/common/Fade.h

/*
 * Copyright (c) 2017 - 2019 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_FADE_H
#define LS_FADE_H

#include "EaseInEaseOut.h"

namespace LinuxSampler {

#define DEFAULT_FADE_CURVE FADE_CURVE_EASE_IN_EASE_OUT

enum fade_curve_t {
    FADE_CURVE_LINEAR,
    FADE_CURVE_EASE_IN_EASE_OUT,
};

/** @brief Fades a value with a selected curve.
 *
 * Implements a smoothed transition from one value to another value in a
 * requested amount of time, either with an ease-in and ease-out algorithm 
 * (default), or linear.
 */
class Fade : public EaseInEaseOut {
public:
    Fade() : EaseInEaseOut() {
        curveType = DEFAULT_FADE_CURVE;
        Final = false;
    }

    /**
     * Select another curve type for this Fade and immediately prepare this
     * Fade for operation with the new curve type.
     */
    void setCurve(fade_curve_t curve, float sampleRate) {
        curveType = curve;
        fadeTo(endValue, duration, sampleRate);
    }

    /**
     * Only set the new curve type. It is your responsibility to prepare this
     * Fade for subsequent operation, i.e. by calling fadeTo() afterwards,
     * otherwise the result of render() calls will be undefined.
     */
    void setCurveOnly(fade_curve_t curve) {
        curveType = curve;
    }

    /**
     * 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 (curveType == FADE_CURVE_EASE_IN_EASE_OUT)
            return EaseInEaseOut::fadeTo(endValue, duration, sampleRate);
        else {
            if (duration <= 0.f) {
                setCurrentValue(endValue);
                return;
            }
            this->endValue = endValue;
            steps = duration * sampleRate;
            c = (endValue - value) / float(steps);
        }
    }

    /**
     * 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 (curveType == FADE_CURVE_EASE_IN_EASE_OUT)
            return EaseInEaseOut::render();
        if (!steps) return endValue;
        --steps;
        value += c;
        return value;
    }

    inline void setFinal(bool b) {
        Final = b;
    }

    template<typename T>
    inline void applyTo(T& dst) {
        if (Final)
            dst = currentValue();
        else
            dst *= currentValue();
    }

private:
    fade_curve_t curveType;
    bool Final;
};

} // namespace LinuxSampler

#endif // LS_FADE_H
1	/*
2	* Copyright (c) 2017 - 2019 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_FADE_H
11	#define LS_FADE_H
12
13	#include "EaseInEaseOut.h"
14
15	namespace LinuxSampler {
16
17	#define DEFAULT_FADE_CURVE FADE_CURVE_EASE_IN_EASE_OUT
18
19	enum fade_curve_t {
20	FADE_CURVE_LINEAR,
21	FADE_CURVE_EASE_IN_EASE_OUT,
22	};
23
24	/** @brief Fades a value with a selected curve.
25	*
26	* Implements a smoothed transition from one value to another value in a
27	* requested amount of time, either with an ease-in and ease-out algorithm
28	* (default), or linear.
29	*/
30	class Fade : public EaseInEaseOut {
31	public:
32	Fade() : EaseInEaseOut() {
33	curveType = DEFAULT_FADE_CURVE;
34	Final = false;
35	}
36
37	/**
38	* Select another curve type for this Fade and immediately prepare this
39	* Fade for operation with the new curve type.
40	*/
41	void setCurve(fade_curve_t curve, float sampleRate) {
42	curveType = curve;
43	fadeTo(endValue, duration, sampleRate);
44	}
45
46	/**
47	* Only set the new curve type. It is your responsibility to prepare this
48	* Fade for subsequent operation, i.e. by calling fadeTo() afterwards,
49	* otherwise the result of render() calls will be undefined.
50	*/
51	void setCurveOnly(fade_curve_t curve) {
52	curveType = curve;
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 (curveType == FADE_CURVE_EASE_IN_EASE_OUT)
61	return EaseInEaseOut::fadeTo(endValue, duration, sampleRate);
62	else {
63	if (duration <= 0.f) {
64	setCurrentValue(endValue);
65	return;
66	}
67	this->endValue = endValue;
68	steps = duration * sampleRate;
69	c = (endValue - value) / float(steps);
70	}
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 (curveType == FADE_CURVE_EASE_IN_EASE_OUT)
87	return EaseInEaseOut::render();
88	if (!steps) return endValue;
89	--steps;
90	value += c;
91	return value;
92	}
93
94	inline void setFinal(bool b) {
95	Final = b;
96	}
97
98	template<typename T>
99	inline void applyTo(T& dst) {
100	if (Final)
101	dst = currentValue();
102	else
103	dst *= currentValue();
104	}
105
106	private:
107	fade_curve_t curveType;
108	bool Final;
109	};
110
111	} // namespace LinuxSampler
112
113	#endif // LS_FADE_H