Interp.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Alge/Trig.h"
#include "Honey/Math/Alge/Transform.h"

namespace honey
{

template<class Real>
class Interp_ : mt::NoCopy
{
    typedef typename Numeral<Real>::Real_ Real_;
    typedef Alge_<Real>         Alge;
    typedef Trig_<Real>         Trig;
    typedef Vec<2,Real>         Vec2;
    typedef Vec<3,Real>         Vec3;
    typedef Vec<4,Real>         Vec4;
    typedef Quat_<Real>         Quat;
    typedef Matrix<4,4,Real>    Matrix4;
    typedef Transform_<Real>    Transform;

public:

    template<class T>
    static T linear(Real t, const T& a, const T& b)                             { return a + t*(b-a); }
    static Quat linear(Real t, const Quat& a, const Quat& b)                    { return Quat::slerp(t, a, b); }

    static Transform linear(Real t, const Transform& a, const Transform& b)
    {
        if (t <= 0)
            return a;
        if (t >= 1)
            return b;

        return Transform(
            linear(t, a.getTrans(), b.getTrans()),
            (a.hasRot() || b.hasRot()) ? linear(t, a.getRot(), b.getRot()) : a.getRot(),
            (a.hasScale() || b.hasScale()) ? linear(t, a.getScale(), b.getScale()) : a.getScale(),
            (a.hasSkew() || b.hasSkew()) ? linear(t, a.getSkew(), b.getSkew()) : a.getSkew()
            );
    }

    static Real linearAngle(Real t, Real angleStart, Real angleEnd, optional<int&> rotSign = optnull);

    static void alignDir(Vec3& dir, const Vec3& targetDir, Real angleAmount, optional<int&> rotSign = optnull);


    template<class T>
    static T baryCentric(Real f, Real g, const T& x0, const T& x1, const T& x2)
    {
        return (1-f-g)*x0 + f*x1 + g*x2;
    }

    static Quat baryCentric(Real f, Real g, const Quat& q0, const Quat& q1, const Quat& q2)
    {
        return Quat::baryCentric(f, g, q0, q1, q2);
    }

    static Transform baryCentric(Real f, Real g, const Transform& tm0, const Transform& tm1, const Transform& tm2)
    {
        Real t = f+g;
        return t != 0 ? linear(g/t, linear(t, tm0, tm1), linear(t, tm0, tm2)) : tm0;
    }

    template<class Range, class Seq>
    static auto blend(Range&& vals, Seq&& weights_) -> mt_elemOf(vals)
    {
        auto val = begin(vals), last = end(vals);
        auto weights = seqToIter(weights_);
        //Get first non-zero weight, if not found then return first value
        for (; val != last && *weights == 0; ++val, ++weights);
        if (val == last) return *begin(vals);
        //Blend the values
        mt_elemOf(vals) ret(*val++);
        Real weightAccum = *weights++;
        for (; val != last; ++val, ++weights)
        {
            weightAccum += *weights;
            Real weight = *weights / weightAccum;
            ret = linear(weight, ret, *val);
        }
        return ret;
    }


    static Real sin(Real t, bool smoothIn, bool smoothOut)
    {
        if (smoothIn && smoothOut)
            return 0.5 - (Trig::sin(Real_::piHalf + t*Real_::pi)/2);
        else if (smoothIn)
            return 1 - Trig::sin(Real_::piHalf + t*Real_::piHalf);
        else
            return Trig::sin(t*Real_::piHalf);
    }


    static Real gaussian(Real x, Real offset, Real scale)
    {
        static const Real sqrtTwoPi = Alge::sqrt(Real_::piTwo);
        return Alge::exp( -Alge::sqr(x - offset) / (2 * Alge::sqr(scale)) ) / ( scale * sqrtTwoPi );
    }

    template<class T>
    static typename MatrixBase<T>::MatrixS gaussian(const MatrixBase<T>& x, const MatrixBase<T>& offset, const MatrixBase<T>& scale)
    {
        assert(x.size() == offset.size() && x.size() == scale.size());
        return map(x, offset, scale, typename MatrixBase<T>::MatrixS().resize(x.rows(), x.cols()),
            [](Real x, Real offset, Real scale) { return gaussian(x, offset, scale); });
    }


    template<class T>
    static T bezier(Real t, const T& v0, const T& v1, const T& v2, const T& v3)
    {
        T c = 3 * (v1 - v0);
        T b = 3 * (v2 - v1) - c;
        T a = v3 - v0 - c - b; 
        Real tSqr = t * t;
        Real tCube = tSqr * t;
        return (a * tCube) + (b * tSqr) + (c * t) + v0;
    }


    static tuple<Vec3, int> bezierRoots(Real y, Real v0, Real v1, Real v2, Real v3);
    
    static tuple<Vec2, Vec2> bezierNormalizeHandles(const Vec2& v0, const Vec2& v1, const Vec2& v2, const Vec2& v3);
    
    static Real bezierAtTime(Real time, const Vec2& v0, const Vec2& v1, const Vec2& v2, const Vec2& v3);
    
    static Real bezierAngleAtTime(Real time, const Vec2& v0, const Vec2& v1, const Vec2& v2, const Vec2& v3);
    
    static void bezierSubdiv(vector<Vec2>& cs, int index, Real t);
    

    static Real bezierSubdivAdapt(vector<Vec2>& cs, int index, Real tol = 0.01);


    static Matrix4 bezierPatchCoeff(const Matrix4& val)
    {
        // Bezier basis matrix
        static const Matrix4 m(             
          -1,   3, -3,  1,
           3,  -6,  3,  0,
          -3,   3,  0,  0,
           1,   0,  0,  0
           );
        static const Matrix4 t = m.transpose();
        return m * (val * t);
    }


    static Real bezierPatch(const Matrix4& coeff, Real x, Real y)
    {
        return  x*( x*( x*(y * (y * (y * coeff( 0) + coeff( 1)) + coeff( 2)) + coeff( 3))
                        + (y * (y * (y * coeff( 4) + coeff( 5)) + coeff( 6)) + coeff( 7))
                      ) + (y * (y * (y * coeff( 8) + coeff( 9)) + coeff(10)) + coeff(11))
                  )     + (y * (y * (y * coeff(12) + coeff(13)) + coeff(14)) + coeff(15));
    }



    template<class T>
    static T catmull(Real t, const T& v0, const T& v1, const T& v2, const T& v3)
    {
        T c1 = -0.5*v0           +  0.5*v2           ;
        T c2 =      v0 + -2.5*v1 +    2*v2 + -0.5*v3 ;
        T c3 = -0.5*v0 +  1.5*v1 + -1.5*v2 +  0.5*v3 ;
        return (((c3*t + c2)*t +c1)*t + v1);
    }


    static Matrix4 catmullPatchCoeff(const Matrix4& val)
    {
        // Catmull-Rom basis matrix
        static const Matrix4 m(             
          -0.5,  1.5, -1.5,  0.5,
           1,   -2.5,    2, -0.5,
          -0.5,    0,  0.5,    0,
           0,      1,    0,    0
           );
        static const Matrix4 t = m.transpose();

        return m * (val * t);
    }


    static Real catmullPatch(const Matrix4& coeff, Real x, Real y)
    {
        return  x*( x*( x*(y * (y * (y * coeff( 0) + coeff( 1)) + coeff( 2)) + coeff( 3))
                        + (y * (y * (y * coeff( 4) + coeff( 5)) + coeff( 6)) + coeff( 7))
                      ) + (y * (y * (y * coeff( 8) + coeff( 9)) + coeff(10)) + coeff(11))
                  )     + (y * (y * (y * coeff(12) + coeff(13)) + coeff(14)) + coeff(15));
    }

};

typedef Interp_<Real>   Interp;
typedef Interp_<Float>  Interp_f;
typedef Interp_<Double> Interp_d;

extern template class Interp_<Float>;
extern template class Interp_<Double>;
extern template class Interp_<Quad>;

}