Tangent for 5th order Bezier curve

Questions & Answers
1

I’m using Bezier curves for gameobject placement. Mostly it’s enough to use cubic curve but in some cases I need more precision.
I’m not strong in math, so I found 5th order equation in wiki and the curve looks fine. Now I just need set angles. Can anyone help me with tangent equation for 5th order Bezier curve?
[1]:

//Cubic
public Vector3 GetPosition(float t)
        {
            return (1 - t) * (1 - t) * (1 - t) * _p0 
                + 3 * (1 - t) * (1 - t) * t * _p1
                + 3 * (1 - t) * t * t * _p2 
                + t * t * t * _p3;
        }

        public Vector3 GetTangent(float t)
        {
            float u = 1 - t;
            float uu = u * u;
            float tu = t * u;
            float tt = t * t;

            Vector3 P = _p0 * 3 * uu * (-1.0f);
            P += _p1 * 3 * (uu - 2 * tu);
            P += _p2 * 3 * (2 * tu - tt);
            P += _p3 * 3 * tt;

            return P.normalized;
        }

//n5
public Vector3 GetPosition(float t)
        {
            float u = 1 - t;
            float uu = u * u;
            float uuu = uu * u;
            float tt = t * t;
            float ttt = t * tt;

            Vector3 P = _p0 * uu * uuu;
            P += _p1 * 5 * uu * uu * t;
            P += _p2 * 10 * uuu * tt;
            P += _p3 * 10 * ttt * uu;
            P += _p4 * 5 * tt * tt * u;
            P += _p5 * ttt * tt;

            return P;
        }
3

Since I like math I just derived the tangent function myself (actually two times in two different ways):

public Vector3 GetTangent(float t)
{
    float u = 1f - t;
    float uu = u * u;
    float uuu = uu * u;
    float tt = t * t;
    float ttt = t * tt;
    Vector3 T = _p0 * (uuu * u)
        - _p1 * (uuu * (5 * t - 1))
        + _p2 * (2 * t * uu * (5 * t - 2))
        - _p3 * (2 * tt * u * (5 * t - 3))
        + _p4 * (ttt * (5 * t - 4))
        - _p5 * (ttt * t);
    return T;
}

I have no time to test it, so feel free to try it out. Note I would recomment you also put brackets around your factors in your GetPosition method. Otherwise a lot performance would be wasted. A multiplication is carried out left to right by the compiler. So in your code you calculate _p0 * uu which returns a new vector3 and then you multiply that result by uuu. So those would be two Vector*float multiplciations. When you group the float factors in brackets they are calculated first and you only do a single Vector - float multiplication per control point. So something like this:

public Vector3 GetPosition(float t)
{
    float u = 1f - t;
    float uu = u * u;
    float uuu = uu * u;
    float tt = t * t;
    float ttt = t * tt;

    Vector3 P = _p0 * (uu * uuu)
        + _p1 * (5 * u * uuu * t)
        + _p2 * (10 * uuu * tt)
        + _p3 * (10 * ttt * uu)
        + _p4 * (5 * t * ttt * u)
        + _p5 * (tt * ttt);
    return P;
}
2

Suddenly it hit me

        public Vector3 GetTangent(float t)
        {
            Vector3 p1 = GetPosition(t - 0.01f);
            Vector3 p2 = GetPosition(t + 0.01f);

            return (p2-p1).normalized;
        }