Vector4

module ru.nsk.sampler.math.vector;

//math stuff (sqrt, cos, sin)
import std.math;

//'zip', 'repeat', 'take' lie here
import std.range;

//'map' and 'reduce' lie here
import std.algorithm;

//to make char upper case + 'format' - a sprintf-like function
import std.string;

public static immutable X = 0;
public static immutable Y = 1;
public static immutable Z = 2;
public static immutable W = 3;

public struct Vector4
{
    public
    {

        static immutable DIMENSION = 4;

        this(Range)(Range coords) pure
        {
            auto i = 0u;
            foreach (immutable coord; coords)
            {
                this.coords[i] = coord;
                i++;
            }
        }

        this(in float x, in float y, in float z, in float w) pure nothrow
        {
            coords[X] = x;
            coords[Y] = y;
            coords[Z] = z;
            coords[W] = w;
        }

        this(in float x, in float y, in float z) pure nothrow
        {
            coords[X] = x;
            coords[Y] = y;
            coords[Z] = z;
        }

        @property float[] get() pure nothrow
        {
            return coords;
        }

        @property const (float[]) get() const pure nothrow
        {
            return coords;
        }

        alias get this;

        mixin(generatePerCoordAccess("xyzw"));

        auto opUnary(const string op)() const pure if ("-" == op || "+" == op)
        {
            return Vector4 ( coords[0..$-1].map!(op ~ "a") );
        }

        auto opBinary(const string op)(in Vector4 right) const pure if ("-" == op || "+" == op)
        {
            return Vector4 ( zip(this.coords[0..$-1], right.coords[0..$-1]).map!("a[0]" ~ op ~ "a[1]") );
        }

        auto opBinary(const string op)(in float scalar) const pure if ("/" == op || "*" == op)
        {
            return Vector4 ( this.coords[0..$-1].map!( element => mixin(format("element %s scalar", op)) ));
        }

        @property auto opDispatch(const string swizzling)() const pure
            if (swizzling.length == DIMENSION || swizzling.length == DIMENSION - 1)
        {
            immutable expression = "coords".repeat().take(swizzling.length).zip(swizzling)
                .map!( a => format("%s[%c]", a[0], a[1].toUpper()) ).reduce!((a,b) => a ~ "," ~ b);

            mixin( "return Vector4 (" ~ expression ~ ");" );
        }

        auto opEquals(in Vector4 other) const pure nothrow
        {
            return this.coords == other.coords;
        }

    } // public

    private
    {
        static string generatePerCoordAccess(in string coords) pure
        {
            string result = "";

            foreach (immutable name; coords)
            {
            result ~= format("@property pure nothrow ref float %c() { return coords[%c]; }", name, name.toUpper);
            result ~= format("@property pure nothrow float %c() const { return coords[%c]; }", name, name.toUpper);
            }

            return result;
        }

        float[DIMENSION] coords = [0.0f, 0.0f, 0.0f, 1.0f,];

    } // private
};

private float dot(in float[] left, in float[] right) pure
{
    return zip(left, right).map!(a => a[0] * a[1]).reduce!((a, b) => a + b);
}

public
{

    float dot3(T)(in T left, in T right) pure
    {
        return dot(left.coords[0..$-1], right.coords[0..$-1]);
    }

    float dot4(T)(in T left, in T right) pure
    {
        return dot(left.coords[0..$], right.coords[0..$]);
    }

    float norm(T)(in T vector) pure
    {
        return sqrt(dot3(vector, vector));
    }

    T identity(T)(in T vector) pure
    {
        return vector / norm(vector);
    }

    T mul(T)(in T left, in T right) pure
    {
        return Vector4( zip(left.get(), right.get()).map!(a => a[0] * a[1]) );
    }

    auto cross(in Vector4 l, in Vector4 r) pure
    {
        return mul( l.yzx, r.zxy ) - mul( l.zxy, r.yzx );
    }

    auto rotateAroundY(in Vector4 v, in float angleDegrees) pure nothrow
    {
        import ru.nsk.sampler.math.utils:radians;

        immutable angleRadians = radians(angleDegrees);

        immutable c = cos(angleRadians);
        immutable s = sin(angleRadians);

        immutable x = v.x * c - v.z * s;
        immutable y = v.y;
        immutable z = v.x * s + v.z * c;

        return Vector4(x, y, z);
    }

    auto rotateAroundX(in Vector4 v, in float angleDegrees) pure nothrow
    {
        import ru.nsk.sampler.math.utils:radians;

        immutable angleRadians = radians(angleDegrees);

        immutable c = cos(angleRadians);
        immutable s = sin(angleRadians);

        immutable x = v.x;
        immutable y = v.y * c - v.z * s;
        immutable z = v.y * s + v.z * c;

        return Vector4(x, y, z);
    }

} // public

unittest
{
    immutable Vector4 v;

    immutable wwww = v.wwww;
    immutable xwxw = v.xwxw;
    immutable wxxx = v.wxxx;

    assert(wwww == Vector4(1, 1, 1, 1) );
    assert(xwxw == Vector4(0, 1, 0, 1) );
    assert(wxxx == Vector4(1, 0, 0, 0) );
}

unittest
{
    const v = Vector4();

    assert(0.0f == v.norm());
}

unittest
{
    const a = Vector4(1,0,0);
    const b = Vector4(1,1,1);

    assert(1.0f == a.dot3(b));
}

unittest
{
    const a = Vector4(1,0,0);
    const b = Vector4(0,1,0);

    assert(Vector4(0,0,+1) == a.cross(b));
    assert(Vector4(0,0,-1) == b.cross(a));

    assert(Vector4(0,0,0) == cross(Vector4(), Vector4()));
}

unittest
{
    assert (Vector4.sizeof == Vector4.DIMENSION * float.sizeof);
}

unittest
{
    const v = Vector4();

    assert (0.0f == v.x);
    assert (0.0f == v[X]);

    assert (0.0f == v.y);
    assert (0.0f == v[Y]);

    assert (0.0f == v.z);
    assert (0.0f == v[Z]);

    assert (1.0f == v.w);
    assert (1.0f == v[W]);
}

unittest
{
    auto v = Vector4();
    v.x = 2.0f;

    assert (2.0f == v.x);
    assert (2.0f == v[X]);

    assert (0.0f == v.y);
    assert (0.0f == v[Y]);

    assert (0.0f == v.z);
    assert (0.0f == v[Z]);

    assert (1.0f == v.w);
    assert (1.0f == v[W]);
}

unittest
{
    auto v = Vector4();
    v.y = 2.0f;

    assert (0.0f == v.x);
    assert (0.0f == v[X]);

    assert (2.0f == v.y);
    assert (2.0f == v[Y]);

    assert (0.0f == v.z);
    assert (0.0f == v[Z]);

    assert (1.0f == v.w);
    assert (1.0f == v[W]);
}

unittest
{
    auto v = Vector4();
    v.z = 3.0f;

    assert (0.0f == v.x);
    assert (0.0f == v[X]);

    assert (0.0f == v.y);
    assert (0.0f == v[Y]);

    assert (3.0f == v.z);
    assert (3.0f == v[Z]);

    assert (1.0f == v.w);
    assert (1.0f == v[W]);
}

unittest
{
    auto v = Vector4();
    v.w = 2.0f;

    assert (0.0f == v.x);
    assert (0.0f == v[X]);

    assert (0.0f == v.y);
    assert (0.0f == v[Y]);

    assert (0.0f == v.z);
    assert (0.0f == v[Z]);

    assert (2.0f == v.w);
    assert (2.0f == v[W]);
}