struct Vec2
{
  float X, Y;

  Vec2 opDispatch(string Members)()
    if(Members.length == 2)
  {
    mixin(`return typeof(return)(this.` ~ Members[0] ~ `, this.` ~ Members[1] ~`);`);
  }

  Vec3 opDispatch(string Members)()
    if(Members.length == 3)
  {
    mixin(`return typeof(return)(this.` ~ Members[0] ~ `, this.` ~ Members[1] ~ `, this.` ~ Members[2] ~`);`);
  }

  Vec4 opDispatch(string Members)()
    if(Members.length == 4)
  {
    mixin(`return typeof(return)(this.` ~ Members[0] ~ `, this.` ~ Members[1] ~ `, this.` ~ Members[2] ~ `, this.` ~ Members[3] ~`);`);
  }
}

struct Vec3
{
  float X, Y, Z;

  this(float X, float Y, float Z)
  {
    this.X = X;
    this.Y = Y;
    this.Z = Z;
  }

  this(Vec2 V, float Z)
  {
    this.X = V.X;
    this.Y = V.Y;
    this.Z = Z;
  }

  this(float X, Vec2 V)
  {
    this.X = X;
    this.Y = V.X;
    this.Z = V.Y;
  }
}

struct Vec4
{
  union
  {
    struct
    {
      float X, Y, Z, W;
    }

    float[4] Data;
  }

  this(float X, float Y, float Z, float W)
  {
    this.X = X;
    this.Y = Y;
    this.Z = Z;
    this.W = W;
  }

  this(Vec2 V, float Z, float W)
  {
    this.X = V.X;
    this.Y = V.Y;
    this.Z = Z;
    this.W = W;
  }

  this(float X, Vec2 V, float W)
  {
    this.X = X;
    this.Y = V.X;
    this.Z = V.Y;
    this.W = W;
  }

  this(float X, float Y, Vec2 V)
  {
    this.X = X;
    this.Y = Y;
    this.Z = V.X;
    this.W = V.Y;
  }

  this(Vec2 V1, Vec2 V2)
  {
    this.X = V1.X;
    this.Y = V1.Y;
    this.Z = V2.X;
    this.W = V2.Y;
  }

  this(Vec3 V, float W)
  {
    this.X = V.X;
    this.Y = V.Y;
    this.Z = V.Z;
    this.W = W;
  }

  this(float X, Vec3 V)
  {
    this.X = X;
    this.Y = V.X;
    this.Z = V.Y;
    this.W = V.Z;
  }
}

// Vec2
unittest
{
  assert(Vec2(1, 2).X == 1);
  assert(Vec2(1, 2).Y == 2);

  assert(Vec2(1, 2).YX   == Vec2(2, 1));
  assert(Vec2(1, 2).XYX  == Vec3(1, 2, 1));
  assert(Vec2(1, 2).XYXY == Vec4(1, 2, 1, 2));

  static assert(!__traits(compiles, Vec2(1, 2).Foo), "Swizzling is only supposed to work with value members of " ~ Vec2.stringof ~ ".");
  static assert(!__traits(compiles, Vec2(1, 2).XXXXX), "Swizzling output dimension is limited to 4.");
}

// Vec3
unittest
{
  assert(Vec3(1, 2, 3).X == 1);
  assert(Vec3(1, 2, 3).Y == 2);
  assert(Vec3(1, 2, 3).Z == 3);

  assert(Vec3(Vec2(1, 2), 3).X == 1);
  assert(Vec3(Vec2(1, 2), 3).Y == 2);
  assert(Vec3(Vec2(1, 2), 3).Z == 3);

  assert(Vec3(1, Vec2(2, 3)).X == 1);
  assert(Vec3(1, Vec2(2, 3)).Y == 2);
  assert(Vec3(1, Vec2(2, 3)).Z == 3);
}

// Vec4
unittest
{
  assert(Vec4(1, 2, 3, 4).X == 1);
  assert(Vec4(1, 2, 3, 4).Y == 2);
  assert(Vec4(1, 2, 3, 4).Z == 3);
  assert(Vec4(1, 2, 3, 4).W == 4);

  assert(Vec4(Vec2(1, 2), 3, 4).X == 1);
  assert(Vec4(Vec2(1, 2), 3, 4).Y == 2);
  assert(Vec4(Vec2(1, 2), 3, 4).Z == 3);
  assert(Vec4(Vec2(1, 2), 3, 4).W == 4);

  assert(Vec4(1, Vec2(2, 3), 4).X == 1);
  assert(Vec4(1, Vec2(2, 3), 4).Y == 2);
  assert(Vec4(1, Vec2(2, 3), 4).Z == 3);
  assert(Vec4(1, Vec2(2, 3), 4).W == 4);

  assert(Vec4(1, 2, Vec2(3, 4)).X == 1);
  assert(Vec4(1, 2, Vec2(3, 4)).Y == 2);
  assert(Vec4(1, 2, Vec2(3, 4)).Z == 3);
  assert(Vec4(1, 2, Vec2(3, 4)).W == 4);

  assert(Vec4(Vec2(1, 2), Vec2(3, 4)).X == 1);
  assert(Vec4(Vec2(1, 2), Vec2(3, 4)).Y == 2);
  assert(Vec4(Vec2(1, 2), Vec2(3, 4)).Z == 3);
  assert(Vec4(Vec2(1, 2), Vec2(3, 4)).W == 4);

  assert(Vec4(Vec3(1, 2, 3), 4).X == 1);
  assert(Vec4(Vec3(1, 2, 3), 4).Y == 2);
  assert(Vec4(Vec3(1, 2, 3), 4).Z == 3);
  assert(Vec4(Vec3(1, 2, 3), 4).W == 4);

  assert(Vec4(1, Vec3(2, 3, 4)).X == 1);
  assert(Vec4(1, Vec3(2, 3, 4)).Y == 2);
  assert(Vec4(1, Vec3(2, 3, 4)).Z == 3);
  assert(Vec4(1, Vec3(2, 3, 4)).W == 4);
}