CUEasingBezier.h

//
//  CUEasingBezier.h
//  Cornell University Game Library (CUGL)
//
//  This module provides easing function support for sophisticated tweening.
//  This module provides a single class that can represent any bezier easing
//  function. This provides the user with more flexibility than the
//  EasingFunction factory.
//
//  These classe uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  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_BEZIER_H__
#define __CU_EASING_BEZIER_H__

#include <cugl/math/CUVec2.h>
#include "CUEasingFunction.h"
#include <vector>
#include <memory>

namespace cugl {

class EasingBezier :  public std::enable_shared_from_this<EasingBezier> {
#pragma mark -
#pragma mark Internal Helpers
protected:
    Vec2 _c1;
    Vec2 _c2;
    Vec2 _c3;
    
    std::vector<float> _rootset;
     
    void solveQuadraticEquation(float a, float b, float c);
    
    void solveCubicEquation(float a, float b, float c, float d);
   
    
#pragma mark -
#pragma mark Constructors
public:
    EasingBezier();
    
    ~EasingBezier() { dispose();  }
    
    void dispose();
    
    bool init() {
        return init(EasingFunction::Type::LINEAR);
    }
    
    bool init(EasingFunction::Type type);
    
    bool init(float x1, float y1, float x2, float y2);

    bool init(const Vec2& p1, const Vec2& p2) {
        return init(p1.x,p1.y,p2.x,p2.y);
    }

#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<EasingBezier> alloc() {
        std::shared_ptr<EasingBezier> result = std::make_shared<EasingBezier>();
        return (result->init() ? result : nullptr);
    }

    static std::shared_ptr<EasingBezier> alloc(EasingFunction::Type type) {
        std::shared_ptr<EasingBezier> result = std::make_shared<EasingBezier>();
        return (result->init(type) ? result : nullptr);
    }

    static std::shared_ptr<EasingBezier> alloc(float x1, float y1, float x2, float y2) {
        std::shared_ptr<EasingBezier> result = std::make_shared<EasingBezier>();
        return (result->init(x1,y1,x2,y2) ? result : nullptr);
    }

    static std::shared_ptr<EasingBezier> alloc(const Vec2& p1, const Vec2& p2) {
        std::shared_ptr<EasingBezier> result = std::make_shared<EasingBezier>();
        return (result->init(p1,p2) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Easing Support

    float evaluate(float t);

    std::function<float(float)> getEvaluator();
    
};
    
}

#endif /* __CU_EASING_BEZIER_H__ */