CUEasingFunction.h

//
//  CUEasingFunction.h
//  Cornell University Game Library (CUGL)
//
//  This module provides easing function support for sophisticated tweening.
//  All of the easing functions are implemented directly, using the definitions
//  provided by http:://easings.net.
//
//  This class is simply a factory for returning function pointers to the
//  appropriate static method.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Sophie Huang and Walker White
//  Version: 3/12/17
//
#ifndef __CU_EASING_FUNCTION_H__
#define __CU_EASING_FUNCTION_H__
 
#include <cugl/math/CUVec2.h>
#include <vector>
#include <memory>
 
#define ELASTIC_PERIOD 0.3f
 
namespace cugl {
    
class EasingFunction {
public:
    enum class Type : int {
        LINEAR,
        SINE_IN,
        SINE_OUT,
        SINE_IN_OUT,
        QUAD_IN,
        QUAD_OUT,
        QUAD_IN_OUT,
        CUBIC_IN,
        CUBIC_OUT,
        CUBIC_IN_OUT,
        QUART_IN,
        QUART_OUT,
        QUART_IN_OUT,
        QUINT_IN,
        QUINT_OUT,
        QUINT_IN_OUT,
        EXPO_IN,
        EXPO_OUT,
        EXPO_IN_OUT,
        CIRC_IN,
        CIRC_OUT,
        CIRC_IN_OUT,
        BACK_IN,
        BACK_OUT,
        BACK_IN_OUT,
        BOUNCE_IN,
        BOUNCE_OUT,
        BOUNCE_IN_OUT,
        ELASTIC_IN,
        ELASTIC_OUT,
        ELASTIC_IN_OUT
    };
    
    static std::function<float(float)> alloc() {
        return alloc(Type::LINEAR);
    }
 
    static std::function<float(float)> alloc(Type type, float period = ELASTIC_PERIOD);
 
    static float linear(float time);
    
    static float sineIn(float time);
    
    static float sineOut(float time);
    
    static float sineInOut(float time);
    
    static float quadIn(float time);
    
    static float quadOut(float time);
    
    static float quadInOut(float time);
    
    static float cubicIn(float time);
    
    static float cubicOut(float time);
    
    static float cubicInOut(float time);
 
    static float quartIn(float time);
 
    static float quartOut(float time);
 
    static float quartInOut(float time);
    
    static float quintIn(float time);
    
    static float quintOut(float time);
    
    static float quintInOut(float time);
    
    static float expoIn(float time);
    
    static float expoOut(float time);
    
    static float expoInOut(float time);
    
    static float circIn(float time);
    
    static float circOut(float time);
    
    static float circInOut(float time);
    
    static float backIn(float time);
    
    static float backOut(float time);
    
    static float backInOut(float time);
    
    static float bounceIn(float time);
    
    static float bounceOut(float time);
    
    static float bounceInOut(float time);
    
    static float elasticIn(float time, float period);
    
    static float elasticOut(float time, float period);
    
    static float elasticInOut(float time, float period);
    
};
 
}
 
 
#endif /* __CU_EASING_ELASTIC_H__ */