Vector4 get garr => new Vector4(storage[1], storage[3], storage[0], storage[0]);
Vector2 gb #
Vector2 get gb => new Vector2(storage[1], storage[2]);
set gb(Vector2 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; }
Vector3 gba #
Vector3 get gba => new Vector3(storage[1], storage[2], storage[3]);
set gba(Vector3 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 gbaa #
Vector4 get gbaa => new Vector4(storage[1], storage[2], storage[3], storage[3]);
final Vector4 gbab #
Vector4 get gbab => new Vector4(storage[1], storage[2], storage[3], storage[2]);
final Vector4 gbag #
Vector4 get gbag => new Vector4(storage[1], storage[2], storage[3], storage[1]);
Vector4 gbar #
Vector4 get gbar => new Vector4(storage[1], storage[2], storage[3], storage[0]);
set gbar(Vector4 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 gbba #
Vector4 get gbba => new Vector4(storage[1], storage[2], storage[2], storage[3]);
final Vector4 gbbb #
Vector4 get gbbb => new Vector4(storage[1], storage[2], storage[2], storage[2]);
final Vector4 gbbg #
Vector4 get gbbg => new Vector4(storage[1], storage[2], storage[2], storage[1]);
final Vector4 gbbr #
Vector4 get gbbr => new Vector4(storage[1], storage[2], storage[2], storage[0]);
final Vector4 gbga #
Vector4 get gbga => new Vector4(storage[1], storage[2], storage[1], storage[3]);
final Vector4 gbgb #
Vector4 get gbgb => new Vector4(storage[1], storage[2], storage[1], storage[2]);
final Vector4 gbgg #
Vector4 get gbgg => new Vector4(storage[1], storage[2], storage[1], storage[1]);
final Vector4 gbgr #
Vector4 get gbgr => new Vector4(storage[1], storage[2], storage[1], storage[0]);
Vector3 gbr #
Vector3 get gbr => new Vector3(storage[1], storage[2], storage[0]);
set gbr(Vector3 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; }
Vector4 gbra #
Vector4 get gbra => new Vector4(storage[1], storage[2], storage[0], storage[3]);
set gbra(Vector4 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 gbrb #
Vector4 get gbrb => new Vector4(storage[1], storage[2], storage[0], storage[2]);
final Vector4 gbrg #
Vector4 get gbrg => new Vector4(storage[1], storage[2], storage[0], storage[1]);
final Vector4 gbrr #
Vector4 get gbrr => new Vector4(storage[1], storage[2], storage[0], storage[0]);
final Vector4 ggaa #
Vector4 get ggaa => new Vector4(storage[1], storage[1], storage[3], storage[3]);
final Vector4 ggab #
Vector4 get ggab => new Vector4(storage[1], storage[1], storage[3], storage[2]);
final Vector4 ggag #
Vector4 get ggag => new Vector4(storage[1], storage[1], storage[3], storage[1]);
final Vector4 ggar #
Vector4 get ggar => new Vector4(storage[1], storage[1], storage[3], storage[0]);
final Vector4 ggba #
Vector4 get ggba => new Vector4(storage[1], storage[1], storage[2], storage[3]);
final Vector4 ggbb #
Vector4 get ggbb => new Vector4(storage[1], storage[1], storage[2], storage[2]);
final Vector4 ggbg #
Vector4 get ggbg => new Vector4(storage[1], storage[1], storage[2], storage[1]);
final Vector4 ggbr #
Vector4 get ggbr => new Vector4(storage[1], storage[1], storage[2], storage[0]);
final Vector4 ggga #
Vector4 get ggga => new Vector4(storage[1], storage[1], storage[1], storage[3]);
final Vector4 gggb #
Vector4 get gggb => new Vector4(storage[1], storage[1], storage[1], storage[2]);
final Vector4 gggg #
Vector4 get gggg => new Vector4(storage[1], storage[1], storage[1], storage[1]);
final Vector4 gggr #
Vector4 get gggr => new Vector4(storage[1], storage[1], storage[1], storage[0]);
final Vector4 ggra #
Vector4 get ggra => new Vector4(storage[1], storage[1], storage[0], storage[3]);
final Vector4 ggrb #
Vector4 get ggrb => new Vector4(storage[1], storage[1], storage[0], storage[2]);
final Vector4 ggrg #
Vector4 get ggrg => new Vector4(storage[1], storage[1], storage[0], storage[1]);
final Vector4 ggrr #
Vector4 get ggrr => new Vector4(storage[1], storage[1], storage[0], storage[0]);
Vector2 gr #
Vector2 get gr => new Vector2(storage[1], storage[0]);
set gr(Vector2 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; }
Vector3 gra #
Vector3 get gra => new Vector3(storage[1], storage[0], storage[3]);
set gra(Vector3 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 graa #
Vector4 get graa => new Vector4(storage[1], storage[0], storage[3], storage[3]);
Vector4 grab #
Vector4 get grab => new Vector4(storage[1], storage[0], storage[3], storage[2]);
set grab(Vector4 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 grag #
Vector4 get grag => new Vector4(storage[1], storage[0], storage[3], storage[1]);
final Vector4 grar #
Vector4 get grar => new Vector4(storage[1], storage[0], storage[3], storage[0]);
Vector3 grb #
Vector3 get grb => new Vector3(storage[1], storage[0], storage[2]);
set grb(Vector3 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; }
Vector4 grba #
Vector4 get grba => new Vector4(storage[1], storage[0], storage[2], storage[3]);
set grba(Vector4 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 grbb #
Vector4 get grbb => new Vector4(storage[1], storage[0], storage[2], storage[2]);
final Vector4 grbg #
Vector4 get grbg => new Vector4(storage[1], storage[0], storage[2], storage[1]);
final Vector4 grbr #
Vector4 get grbr => new Vector4(storage[1], storage[0], storage[2], storage[0]);
final Vector4 grga #
Vector4 get grga => new Vector4(storage[1], storage[0], storage[1], storage[3]);
final Vector4 grgb #
Vector4 get grgb => new Vector4(storage[1], storage[0], storage[1], storage[2]);
final Vector4 grgg #
Vector4 get grgg => new Vector4(storage[1], storage[0], storage[1], storage[1]);
final Vector4 grgr #
Vector4 get grgr => new Vector4(storage[1], storage[0], storage[1], storage[0]);
final Vector4 grra #
Vector4 get grra => new Vector4(storage[1], storage[0], storage[0], storage[3]);
final Vector4 grrb #
Vector4 get grrb => new Vector4(storage[1], storage[0], storage[0], storage[2]);
final Vector4 grrg #
Vector4 get grrg => new Vector4(storage[1], storage[0], storage[0], storage[1]);
final Vector4 grrr #
Vector4 get grrr => new Vector4(storage[1], storage[0], storage[0], storage[0]);
final bool isInfinite #
True if any component is infinite.
bool get isInfinite { bool is_infinite = false; is_infinite = is_infinite || storage[0].isInfinite; is_infinite = is_infinite || storage[1].isInfinite; is_infinite = is_infinite || storage[2].isInfinite; is_infinite = is_infinite || storage[3].isInfinite; return is_infinite; }
final bool isNaN #
True if any component is NaN.
bool get isNaN { bool is_nan = false; is_nan = is_nan || storage[0].isNaN; is_nan = is_nan || storage[1].isNaN; is_nan = is_nan || storage[2].isNaN; is_nan = is_nan || storage[3].isNaN; return is_nan; }
final double length #
Length.
double get length { double sum; sum = (storage[0] * storage[0]); sum += (storage[1] * storage[1]); sum += (storage[2] * storage[2]); sum += (storage[3] * storage[3]); return Math.sqrt(sum); }
final double length2 #
Length squared.
double get length2 { double sum; sum = (storage[0] * storage[0]); sum += (storage[1] * storage[1]); sum += (storage[2] * storage[2]); sum += (storage[3] * storage[3]); return sum; }
final Vector4 pppp #
Vector4 get pppp => new Vector4(storage[2], storage[2], storage[2], storage[2]);
final Vector4 pppq #
Vector4 get pppq => new Vector4(storage[2], storage[2], storage[2], storage[3]);
final Vector4 ppps #
Vector4 get ppps => new Vector4(storage[2], storage[2], storage[2], storage[0]);
final Vector4 pppt #
Vector4 get pppt => new Vector4(storage[2], storage[2], storage[2], storage[1]);
final Vector4 ppqp #
Vector4 get ppqp => new Vector4(storage[2], storage[2], storage[3], storage[2]);
final Vector4 ppqq #
Vector4 get ppqq => new Vector4(storage[2], storage[2], storage[3], storage[3]);
final Vector4 ppqs #
Vector4 get ppqs => new Vector4(storage[2], storage[2], storage[3], storage[0]);
final Vector4 ppqt #
Vector4 get ppqt => new Vector4(storage[2], storage[2], storage[3], storage[1]);
final Vector4 ppsp #
Vector4 get ppsp => new Vector4(storage[2], storage[2], storage[0], storage[2]);
final Vector4 ppsq #
Vector4 get ppsq => new Vector4(storage[2], storage[2], storage[0], storage[3]);
final Vector4 ppss #
Vector4 get ppss => new Vector4(storage[2], storage[2], storage[0], storage[0]);
final Vector4 ppst #
Vector4 get ppst => new Vector4(storage[2], storage[2], storage[0], storage[1]);
final Vector4 pptp #
Vector4 get pptp => new Vector4(storage[2], storage[2], storage[1], storage[2]);
final Vector4 pptq #
Vector4 get pptq => new Vector4(storage[2], storage[2], storage[1], storage[3]);
final Vector4 ppts #
Vector4 get ppts => new Vector4(storage[2], storage[2], storage[1], storage[0]);
final Vector4 pptt #
Vector4 get pptt => new Vector4(storage[2], storage[2], storage[1], storage[1]);
Vector2 pq #
Vector2 get pq => new Vector2(storage[2], storage[3]);
set pq(Vector2 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; }
final Vector4 pqpp #
Vector4 get pqpp => new Vector4(storage[2], storage[3], storage[2], storage[2]);
final Vector4 pqpq #
Vector4 get pqpq => new Vector4(storage[2], storage[3], storage[2], storage[3]);
final Vector4 pqps #
Vector4 get pqps => new Vector4(storage[2], storage[3], storage[2], storage[0]);
final Vector4 pqpt #
Vector4 get pqpt => new Vector4(storage[2], storage[3], storage[2], storage[1]);
final Vector4 pqqp #
Vector4 get pqqp => new Vector4(storage[2], storage[3], storage[3], storage[2]);
final Vector4 pqqq #
Vector4 get pqqq => new Vector4(storage[2], storage[3], storage[3], storage[3]);
final Vector4 pqqs #
Vector4 get pqqs => new Vector4(storage[2], storage[3], storage[3], storage[0]);
final Vector4 pqqt #
Vector4 get pqqt => new Vector4(storage[2], storage[3], storage[3], storage[1]);
Vector3 pqs #
Vector3 get pqs => new Vector3(storage[2], storage[3], storage[0]);
set pqs(Vector3 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 pqsp #
Vector4 get pqsp => new Vector4(storage[2], storage[3], storage[0], storage[2]);
final Vector4 pqsq #
Vector4 get pqsq => new Vector4(storage[2], storage[3], storage[0], storage[3]);
final Vector4 pqss #
Vector4 get pqss => new Vector4(storage[2], storage[3], storage[0], storage[0]);
Vector4 pqst #
Vector4 get pqst => new Vector4(storage[2], storage[3], storage[0], storage[1]);
set pqst(Vector4 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; storage[1] = arg.storage[3]; }
Vector3 pqt #
Vector3 get pqt => new Vector3(storage[2], storage[3], storage[1]);
set pqt(Vector3 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 pqtp #
Vector4 get pqtp => new Vector4(storage[2], storage[3], storage[1], storage[2]);
final Vector4 pqtq #
Vector4 get pqtq => new Vector4(storage[2], storage[3], storage[1], storage[3]);
Vector4 pqts #
Vector4 get pqts => new Vector4(storage[2], storage[3], storage[1], storage[0]);
set pqts(Vector4 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 pqtt #
Vector4 get pqtt => new Vector4(storage[2], storage[3], storage[1], storage[1]);
Vector2 ps #
Vector2 get ps => new Vector2(storage[2], storage[0]);
set ps(Vector2 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; }
final Vector4 pspp #
Vector4 get pspp => new Vector4(storage[2], storage[0], storage[2], storage[2]);
final Vector4 pspq #
Vector4 get pspq => new Vector4(storage[2], storage[0], storage[2], storage[3]);
final Vector4 psps #
Vector4 get psps => new Vector4(storage[2], storage[0], storage[2], storage[0]);
final Vector4 pspt #
Vector4 get pspt => new Vector4(storage[2], storage[0], storage[2], storage[1]);
Vector3 psq #
Vector3 get psq => new Vector3(storage[2], storage[0], storage[3]);
set psq(Vector3 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 psqp #
Vector4 get psqp => new Vector4(storage[2], storage[0], storage[3], storage[2]);
final Vector4 psqq #
Vector4 get psqq => new Vector4(storage[2], storage[0], storage[3], storage[3]);
final Vector4 psqs #
Vector4 get psqs => new Vector4(storage[2], storage[0], storage[3], storage[0]);
Vector4 psqt #
Vector4 get psqt => new Vector4(storage[2], storage[0], storage[3], storage[1]);
set psqt(Vector4 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 pssp #
Vector4 get pssp => new Vector4(storage[2], storage[0], storage[0], storage[2]);
final Vector4 pssq #
Vector4 get pssq => new Vector4(storage[2], storage[0], storage[0], storage[3]);
final Vector4 psss #
Vector4 get psss => new Vector4(storage[2], storage[0], storage[0], storage[0]);
final Vector4 psst #
Vector4 get psst => new Vector4(storage[2], storage[0], storage[0], storage[1]);
Vector3 pst #
Vector3 get pst => new Vector3(storage[2], storage[0], storage[1]);
set pst(Vector3 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 pstp #
Vector4 get pstp => new Vector4(storage[2], storage[0], storage[1], storage[2]);
Vector4 pstq #
Vector4 get pstq => new Vector4(storage[2], storage[0], storage[1], storage[3]);
set pstq(Vector4 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 psts #
Vector4 get psts => new Vector4(storage[2], storage[0], storage[1], storage[0]);
final Vector4 pstt #
Vector4 get pstt => new Vector4(storage[2], storage[0], storage[1], storage[1]);
Vector2 pt #
Vector2 get pt => new Vector2(storage[2], storage[1]);
set pt(Vector2 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; }
final Vector4 ptpp #
Vector4 get ptpp => new Vector4(storage[2], storage[1], storage[2], storage[2]);
final Vector4 ptpq #
Vector4 get ptpq => new Vector4(storage[2], storage[1], storage[2], storage[3]);
final Vector4 ptps #
Vector4 get ptps => new Vector4(storage[2], storage[1], storage[2], storage[0]);
final Vector4 ptpt #
Vector4 get ptpt => new Vector4(storage[2], storage[1], storage[2], storage[1]);
Vector3 ptq #
Vector3 get ptq => new Vector3(storage[2], storage[1], storage[3]);
set ptq(Vector3 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 ptqp #
Vector4 get ptqp => new Vector4(storage[2], storage[1], storage[3], storage[2]);
final Vector4 ptqq #
Vector4 get ptqq => new Vector4(storage[2], storage[1], storage[3], storage[3]);
Vector4 ptqs #
Vector4 get ptqs => new Vector4(storage[2], storage[1], storage[3], storage[0]);
set ptqs(Vector4 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 ptqt #
Vector4 get ptqt => new Vector4(storage[2], storage[1], storage[3], storage[1]);
Vector3 pts #
Vector3 get pts => new Vector3(storage[2], storage[1], storage[0]);
set pts(Vector3 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 ptsp #
Vector4 get ptsp => new Vector4(storage[2], storage[1], storage[0], storage[2]);
Vector4 ptsq #
Vector4 get ptsq => new Vector4(storage[2], storage[1], storage[0], storage[3]);
set ptsq(Vector4 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 ptss #
Vector4 get ptss => new Vector4(storage[2], storage[1], storage[0], storage[0]);
final Vector4 ptst #
Vector4 get ptst => new Vector4(storage[2], storage[1], storage[0], storage[1]);
final Vector4 pttp #
Vector4 get pttp => new Vector4(storage[2], storage[1], storage[1], storage[2]);
final Vector4 pttq #
Vector4 get pttq => new Vector4(storage[2], storage[1], storage[1], storage[3]);
final Vector4 ptts #
Vector4 get ptts => new Vector4(storage[2], storage[1], storage[1], storage[0]);
final Vector4 pttt #
Vector4 get pttt => new Vector4(storage[2], storage[1], storage[1], storage[1]);
Vector2 qp #
Vector2 get qp => new Vector2(storage[3], storage[2]);
set qp(Vector2 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; }
final Vector4 qppp #
Vector4 get qppp => new Vector4(storage[3], storage[2], storage[2], storage[2]);
final Vector4 qppq #
Vector4 get qppq => new Vector4(storage[3], storage[2], storage[2], storage[3]);
final Vector4 qpps #
Vector4 get qpps => new Vector4(storage[3], storage[2], storage[2], storage[0]);
final Vector4 qppt #
Vector4 get qppt => new Vector4(storage[3], storage[2], storage[2], storage[1]);
final Vector4 qpqp #
Vector4 get qpqp => new Vector4(storage[3], storage[2], storage[3], storage[2]);
final Vector4 qpqq #
Vector4 get qpqq => new Vector4(storage[3], storage[2], storage[3], storage[3]);
final Vector4 qpqs #
Vector4 get qpqs => new Vector4(storage[3], storage[2], storage[3], storage[0]);
final Vector4 qpqt #
Vector4 get qpqt => new Vector4(storage[3], storage[2], storage[3], storage[1]);
Vector3 qps #
Vector3 get qps => new Vector3(storage[3], storage[2], storage[0]);
set qps(Vector3 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 qpsp #
Vector4 get qpsp => new Vector4(storage[3], storage[2], storage[0], storage[2]);
final Vector4 qpsq #
Vector4 get qpsq => new Vector4(storage[3], storage[2], storage[0], storage[3]);
final Vector4 qpss #
Vector4 get qpss => new Vector4(storage[3], storage[2], storage[0], storage[0]);
Vector4 qpst #
Vector4 get qpst => new Vector4(storage[3], storage[2], storage[0], storage[1]);
set qpst(Vector4 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; storage[1] = arg.storage[3]; }
Vector3 qpt #
Vector3 get qpt => new Vector3(storage[3], storage[2], storage[1]);
set qpt(Vector3 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 qptp #
Vector4 get qptp => new Vector4(storage[3], storage[2], storage[1], storage[2]);
final Vector4 qptq #
Vector4 get qptq => new Vector4(storage[3], storage[2], storage[1], storage[3]);
Vector4 qpts #
Vector4 get qpts => new Vector4(storage[3], storage[2], storage[1], storage[0]);
set qpts(Vector4 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 qptt #
Vector4 get qptt => new Vector4(storage[3], storage[2], storage[1], storage[1]);
final Vector4 qqpp #
Vector4 get qqpp => new Vector4(storage[3], storage[3], storage[2], storage[2]);
final Vector4 qqpq #
Vector4 get qqpq => new Vector4(storage[3], storage[3], storage[2], storage[3]);
final Vector4 qqps #
Vector4 get qqps => new Vector4(storage[3], storage[3], storage[2], storage[0]);
final Vector4 qqpt #
Vector4 get qqpt => new Vector4(storage[3], storage[3], storage[2], storage[1]);
final Vector4 qqqp #
Vector4 get qqqp => new Vector4(storage[3], storage[3], storage[3], storage[2]);
final Vector4 qqqq #
Vector4 get qqqq => new Vector4(storage[3], storage[3], storage[3], storage[3]);
final Vector4 qqqs #
Vector4 get qqqs => new Vector4(storage[3], storage[3], storage[3], storage[0]);
final Vector4 qqqt #
Vector4 get qqqt => new Vector4(storage[3], storage[3], storage[3], storage[1]);
final Vector4 qqsp #
Vector4 get qqsp => new Vector4(storage[3], storage[3], storage[0], storage[2]);
final Vector4 qqsq #
Vector4 get qqsq => new Vector4(storage[3], storage[3], storage[0], storage[3]);
final Vector4 qqss #
Vector4 get qqss => new Vector4(storage[3], storage[3], storage[0], storage[0]);
final Vector4 qqst #
Vector4 get qqst => new Vector4(storage[3], storage[3], storage[0], storage[1]);
final Vector4 qqtp #
Vector4 get qqtp => new Vector4(storage[3], storage[3], storage[1], storage[2]);
final Vector4 qqtq #
Vector4 get qqtq => new Vector4(storage[3], storage[3], storage[1], storage[3]);
final Vector4 qqts #
Vector4 get qqts => new Vector4(storage[3], storage[3], storage[1], storage[0]);
final Vector4 qqtt #
Vector4 get qqtt => new Vector4(storage[3], storage[3], storage[1], storage[1]);
Vector2 qs #
Vector2 get qs => new Vector2(storage[3], storage[0]);
set qs(Vector2 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; }
Vector3 qsp #
Vector3 get qsp => new Vector3(storage[3], storage[0], storage[2]);
set qsp(Vector3 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 qspp #
Vector4 get qspp => new Vector4(storage[3], storage[0], storage[2], storage[2]);
final Vector4 qspq #
Vector4 get qspq => new Vector4(storage[3], storage[0], storage[2], storage[3]);
final Vector4 qsps #
Vector4 get qsps => new Vector4(storage[3], storage[0], storage[2], storage[0]);
Vector4 qspt #
Vector4 get qspt => new Vector4(storage[3], storage[0], storage[2], storage[1]);
set qspt(Vector4 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 qsqp #
Vector4 get qsqp => new Vector4(storage[3], storage[0], storage[3], storage[2]);
final Vector4 qsqq #
Vector4 get qsqq => new Vector4(storage[3], storage[0], storage[3], storage[3]);
final Vector4 qsqs #
Vector4 get qsqs => new Vector4(storage[3], storage[0], storage[3], storage[0]);
final Vector4 qsqt #
Vector4 get qsqt => new Vector4(storage[3], storage[0], storage[3], storage[1]);
final Vector4 qssp #
Vector4 get qssp => new Vector4(storage[3], storage[0], storage[0], storage[2]);
final Vector4 qssq #
Vector4 get qssq => new Vector4(storage[3], storage[0], storage[0], storage[3]);
final Vector4 qsss #
Vector4 get qsss => new Vector4(storage[3], storage[0], storage[0], storage[0]);
final Vector4 qsst #
Vector4 get qsst => new Vector4(storage[3], storage[0], storage[0], storage[1]);
Vector3 qst #
Vector3 get qst => new Vector3(storage[3], storage[0], storage[1]);
set qst(Vector3 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; }
Vector4 qstp #
Vector4 get qstp => new Vector4(storage[3], storage[0], storage[1], storage[2]);
set qstp(Vector4 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 qstq #
Vector4 get qstq => new Vector4(storage[3], storage[0], storage[1], storage[3]);
final Vector4 qsts #
Vector4 get qsts => new Vector4(storage[3], storage[0], storage[1], storage[0]);
final Vector4 qstt #
Vector4 get qstt => new Vector4(storage[3], storage[0], storage[1], storage[1]);
Vector2 qt #
Vector2 get qt => new Vector2(storage[3], storage[1]);
set qt(Vector2 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; }
Vector3 qtp #
Vector3 get qtp => new Vector3(storage[3], storage[1], storage[2]);
set qtp(Vector3 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 qtpp #
Vector4 get qtpp => new Vector4(storage[3], storage[1], storage[2], storage[2]);
final Vector4 qtpq #
Vector4 get qtpq => new Vector4(storage[3], storage[1], storage[2], storage[3]);
Vector4 qtps #
Vector4 get qtps => new Vector4(storage[3], storage[1], storage[2], storage[0]);
set qtps(Vector4 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 qtpt #
Vector4 get qtpt => new Vector4(storage[3], storage[1], storage[2], storage[1]);
final Vector4 qtqp #
Vector4 get qtqp => new Vector4(storage[3], storage[1], storage[3], storage[2]);
final Vector4 qtqq #
Vector4 get qtqq => new Vector4(storage[3], storage[1], storage[3], storage[3]);
final Vector4 qtqs #
Vector4 get qtqs => new Vector4(storage[3], storage[1], storage[3], storage[0]);
final Vector4 qtqt #
Vector4 get qtqt => new Vector4(storage[3], storage[1], storage[3], storage[1]);
Vector3 qts #
Vector3 get qts => new Vector3(storage[3], storage[1], storage[0]);
set qts(Vector3 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; }
Vector4 qtsp #
Vector4 get qtsp => new Vector4(storage[3], storage[1], storage[0], storage[2]);
set qtsp(Vector4 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 qtsq #
Vector4 get qtsq => new Vector4(storage[3], storage[1], storage[0], storage[3]);
final Vector4 qtss #
Vector4 get qtss => new Vector4(storage[3], storage[1], storage[0], storage[0]);
final Vector4 qtst #
Vector4 get qtst => new Vector4(storage[3], storage[1], storage[0], storage[1]);
final Vector4 qttp #
Vector4 get qttp => new Vector4(storage[3], storage[1], storage[1], storage[2]);
final Vector4 qttq #
Vector4 get qttq => new Vector4(storage[3], storage[1], storage[1], storage[3]);
final Vector4 qtts #
Vector4 get qtts => new Vector4(storage[3], storage[1], storage[1], storage[0]);
final Vector4 qttt #
Vector4 get qttt => new Vector4(storage[3], storage[1], storage[1], storage[1]);
Vector2 ra #
Vector2 get ra => new Vector2(storage[0], storage[3]);
set ra(Vector2 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; }
final Vector4 raaa #
Vector4 get raaa => new Vector4(storage[0], storage[3], storage[3], storage[3]);
final Vector4 raab #
Vector4 get raab => new Vector4(storage[0], storage[3], storage[3], storage[2]);
final Vector4 raag #
Vector4 get raag => new Vector4(storage[0], storage[3], storage[3], storage[1]);
final Vector4 raar #
Vector4 get raar => new Vector4(storage[0], storage[3], storage[3], storage[0]);
Vector3 rab #
Vector3 get rab => new Vector3(storage[0], storage[3], storage[2]);
set rab(Vector3 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 raba #
Vector4 get raba => new Vector4(storage[0], storage[3], storage[2], storage[3]);
final Vector4 rabb #
Vector4 get rabb => new Vector4(storage[0], storage[3], storage[2], storage[2]);
Vector4 rabg #
Vector4 get rabg => new Vector4(storage[0], storage[3], storage[2], storage[1]);
set rabg(Vector4 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 rabr #
Vector4 get rabr => new Vector4(storage[0], storage[3], storage[2], storage[0]);
Vector3 rag #
Vector3 get rag => new Vector3(storage[0], storage[3], storage[1]);
set rag(Vector3 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 raga #
Vector4 get raga => new Vector4(storage[0], storage[3], storage[1], storage[3]);
Vector4 ragb #
Vector4 get ragb => new Vector4(storage[0], storage[3], storage[1], storage[2]);
set ragb(Vector4 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 ragg #
Vector4 get ragg => new Vector4(storage[0], storage[3], storage[1], storage[1]);
final Vector4 ragr #
Vector4 get ragr => new Vector4(storage[0], storage[3], storage[1], storage[0]);
final Vector4 rara #
Vector4 get rara => new Vector4(storage[0], storage[3], storage[0], storage[3]);
final Vector4 rarb #
Vector4 get rarb => new Vector4(storage[0], storage[3], storage[0], storage[2]);
final Vector4 rarg #
Vector4 get rarg => new Vector4(storage[0], storage[3], storage[0], storage[1]);
final Vector4 rarr #
Vector4 get rarr => new Vector4(storage[0], storage[3], storage[0], storage[0]);
Vector2 rb #
Vector2 get rb => new Vector2(storage[0], storage[2]);
set rb(Vector2 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; }
Vector3 rba #
Vector3 get rba => new Vector3(storage[0], storage[2], storage[3]);
set rba(Vector3 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 rbaa #
Vector4 get rbaa => new Vector4(storage[0], storage[2], storage[3], storage[3]);
final Vector4 rbab #
Vector4 get rbab => new Vector4(storage[0], storage[2], storage[3], storage[2]);
Vector4 rbag #
Vector4 get rbag => new Vector4(storage[0], storage[2], storage[3], storage[1]);
set rbag(Vector4 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 rbar #
Vector4 get rbar => new Vector4(storage[0], storage[2], storage[3], storage[0]);
final Vector4 rbba #
Vector4 get rbba => new Vector4(storage[0], storage[2], storage[2], storage[3]);
final Vector4 rbbb #
Vector4 get rbbb => new Vector4(storage[0], storage[2], storage[2], storage[2]);
final Vector4 rbbg #
Vector4 get rbbg => new Vector4(storage[0], storage[2], storage[2], storage[1]);
final Vector4 rbbr #
Vector4 get rbbr => new Vector4(storage[0], storage[2], storage[2], storage[0]);
Vector3 rbg #
Vector3 get rbg => new Vector3(storage[0], storage[2], storage[1]);
set rbg(Vector3 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; }
Vector4 rbga #
Vector4 get rbga => new Vector4(storage[0], storage[2], storage[1], storage[3]);
set rbga(Vector4 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 rbgb #
Vector4 get rbgb => new Vector4(storage[0], storage[2], storage[1], storage[2]);
final Vector4 rbgg #
Vector4 get rbgg => new Vector4(storage[0], storage[2], storage[1], storage[1]);
final Vector4 rbgr #
Vector4 get rbgr => new Vector4(storage[0], storage[2], storage[1], storage[0]);
final Vector4 rbra #
Vector4 get rbra => new Vector4(storage[0], storage[2], storage[0], storage[3]);
final Vector4 rbrb #
Vector4 get rbrb => new Vector4(storage[0], storage[2], storage[0], storage[2]);
final Vector4 rbrg #
Vector4 get rbrg => new Vector4(storage[0], storage[2], storage[0], storage[1]);
final Vector4 rbrr #
Vector4 get rbrr => new Vector4(storage[0], storage[2], storage[0], storage[0]);
Vector2 rg #
Vector2 get rg => new Vector2(storage[0], storage[1]);
set rg(Vector2 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; }
Vector3 rga #
Vector3 get rga => new Vector3(storage[0], storage[1], storage[3]);
set rga(Vector3 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 rgaa #
Vector4 get rgaa => new Vector4(storage[0], storage[1], storage[3], storage[3]);
Vector4 rgab #
Vector4 get rgab => new Vector4(storage[0], storage[1], storage[3], storage[2]);
set rgab(Vector4 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 rgag #
Vector4 get rgag => new Vector4(storage[0], storage[1], storage[3], storage[1]);
final Vector4 rgar #
Vector4 get rgar => new Vector4(storage[0], storage[1], storage[3], storage[0]);
Vector3 rgb #
Vector3 get rgb => new Vector3(storage[0], storage[1], storage[2]);
set rgb(Vector3 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; }
Vector4 rgba #
Vector4 get rgba => new Vector4(storage[0], storage[1], storage[2], storage[3]);
set rgba(Vector4 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 rgbb #
Vector4 get rgbb => new Vector4(storage[0], storage[1], storage[2], storage[2]);
final Vector4 rgbg #
Vector4 get rgbg => new Vector4(storage[0], storage[1], storage[2], storage[1]);
final Vector4 rgbr #
Vector4 get rgbr => new Vector4(storage[0], storage[1], storage[2], storage[0]);
final Vector4 rgga #
Vector4 get rgga => new Vector4(storage[0], storage[1], storage[1], storage[3]);
final Vector4 rggb #
Vector4 get rggb => new Vector4(storage[0], storage[1], storage[1], storage[2]);
final Vector4 rggg #
Vector4 get rggg => new Vector4(storage[0], storage[1], storage[1], storage[1]);
final Vector4 rggr #
Vector4 get rggr => new Vector4(storage[0], storage[1], storage[1], storage[0]);
final Vector4 rgra #
Vector4 get rgra => new Vector4(storage[0], storage[1], storage[0], storage[3]);
final Vector4 rgrb #
Vector4 get rgrb => new Vector4(storage[0], storage[1], storage[0], storage[2]);
final Vector4 rgrg #
Vector4 get rgrg => new Vector4(storage[0], storage[1], storage[0], storage[1]);
final Vector4 rgrr #
Vector4 get rgrr => new Vector4(storage[0], storage[1], storage[0], storage[0]);
final Vector4 rraa #
Vector4 get rraa => new Vector4(storage[0], storage[0], storage[3], storage[3]);
final Vector4 rrab #
Vector4 get rrab => new Vector4(storage[0], storage[0], storage[3], storage[2]);
final Vector4 rrag #
Vector4 get rrag => new Vector4(storage[0], storage[0], storage[3], storage[1]);
final Vector4 rrar #
Vector4 get rrar => new Vector4(storage[0], storage[0], storage[3], storage[0]);
final Vector4 rrba #
Vector4 get rrba => new Vector4(storage[0], storage[0], storage[2], storage[3]);
final Vector4 rrbb #
Vector4 get rrbb => new Vector4(storage[0], storage[0], storage[2], storage[2]);
final Vector4 rrbg #
Vector4 get rrbg => new Vector4(storage[0], storage[0], storage[2], storage[1]);
final Vector4 rrbr #
Vector4 get rrbr => new Vector4(storage[0], storage[0], storage[2], storage[0]);
final Vector4 rrga #
Vector4 get rrga => new Vector4(storage[0], storage[0], storage[1], storage[3]);
final Vector4 rrgb #
Vector4 get rrgb => new Vector4(storage[0], storage[0], storage[1], storage[2]);
final Vector4 rrgg #
Vector4 get rrgg => new Vector4(storage[0], storage[0], storage[1], storage[1]);
final Vector4 rrgr #
Vector4 get rrgr => new Vector4(storage[0], storage[0], storage[1], storage[0]);
final Vector4 rrra #
Vector4 get rrra => new Vector4(storage[0], storage[0], storage[0], storage[3]);
final Vector4 rrrb #
Vector4 get rrrb => new Vector4(storage[0], storage[0], storage[0], storage[2]);
final Vector4 rrrg #
Vector4 get rrrg => new Vector4(storage[0], storage[0], storage[0], storage[1]);
final Vector4 rrrr #
Vector4 get rrrr => new Vector4(storage[0], storage[0], storage[0], storage[0]);
Vector2 sp #
Vector2 get sp => new Vector2(storage[0], storage[2]);
set sp(Vector2 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; }
final Vector4 sppp #
Vector4 get sppp => new Vector4(storage[0], storage[2], storage[2], storage[2]);
final Vector4 sppq #
Vector4 get sppq => new Vector4(storage[0], storage[2], storage[2], storage[3]);
final Vector4 spps #
Vector4 get spps => new Vector4(storage[0], storage[2], storage[2], storage[0]);
final Vector4 sppt #
Vector4 get sppt => new Vector4(storage[0], storage[2], storage[2], storage[1]);
Vector3 spq #
Vector3 get spq => new Vector3(storage[0], storage[2], storage[3]);
set spq(Vector3 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 spqp #
Vector4 get spqp => new Vector4(storage[0], storage[2], storage[3], storage[2]);
final Vector4 spqq #
Vector4 get spqq => new Vector4(storage[0], storage[2], storage[3], storage[3]);
final Vector4 spqs #
Vector4 get spqs => new Vector4(storage[0], storage[2], storage[3], storage[0]);
Vector4 spqt #
Vector4 get spqt => new Vector4(storage[0], storage[2], storage[3], storage[1]);
set spqt(Vector4 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 spsp #
Vector4 get spsp => new Vector4(storage[0], storage[2], storage[0], storage[2]);
final Vector4 spsq #
Vector4 get spsq => new Vector4(storage[0], storage[2], storage[0], storage[3]);
final Vector4 spss #
Vector4 get spss => new Vector4(storage[0], storage[2], storage[0], storage[0]);
final Vector4 spst #
Vector4 get spst => new Vector4(storage[0], storage[2], storage[0], storage[1]);
Vector3 spt #
Vector3 get spt => new Vector3(storage[0], storage[2], storage[1]);
set spt(Vector3 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 sptp #
Vector4 get sptp => new Vector4(storage[0], storage[2], storage[1], storage[2]);
Vector4 sptq #
Vector4 get sptq => new Vector4(storage[0], storage[2], storage[1], storage[3]);
set sptq(Vector4 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 spts #
Vector4 get spts => new Vector4(storage[0], storage[2], storage[1], storage[0]);
final Vector4 sptt #
Vector4 get sptt => new Vector4(storage[0], storage[2], storage[1], storage[1]);
Vector2 sq #
Vector2 get sq => new Vector2(storage[0], storage[3]);
set sq(Vector2 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; }
Vector3 sqp #
Vector3 get sqp => new Vector3(storage[0], storage[3], storage[2]);
set sqp(Vector3 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 sqpp #
Vector4 get sqpp => new Vector4(storage[0], storage[3], storage[2], storage[2]);
final Vector4 sqpq #
Vector4 get sqpq => new Vector4(storage[0], storage[3], storage[2], storage[3]);
final Vector4 sqps #
Vector4 get sqps => new Vector4(storage[0], storage[3], storage[2], storage[0]);
Vector4 sqpt #
Vector4 get sqpt => new Vector4(storage[0], storage[3], storage[2], storage[1]);
set sqpt(Vector4 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 sqqp #
Vector4 get sqqp => new Vector4(storage[0], storage[3], storage[3], storage[2]);
final Vector4 sqqq #
Vector4 get sqqq => new Vector4(storage[0], storage[3], storage[3], storage[3]);
final Vector4 sqqs #
Vector4 get sqqs => new Vector4(storage[0], storage[3], storage[3], storage[0]);
final Vector4 sqqt #
Vector4 get sqqt => new Vector4(storage[0], storage[3], storage[3], storage[1]);
final Vector4 sqsp #
Vector4 get sqsp => new Vector4(storage[0], storage[3], storage[0], storage[2]);
final Vector4 sqsq #
Vector4 get sqsq => new Vector4(storage[0], storage[3], storage[0], storage[3]);
final Vector4 sqss #
Vector4 get sqss => new Vector4(storage[0], storage[3], storage[0], storage[0]);
final Vector4 sqst #
Vector4 get sqst => new Vector4(storage[0], storage[3], storage[0], storage[1]);
Vector3 sqt #
Vector3 get sqt => new Vector3(storage[0], storage[3], storage[1]);
set sqt(Vector3 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; }
Vector4 sqtp #
Vector4 get sqtp => new Vector4(storage[0], storage[3], storage[1], storage[2]);
set sqtp(Vector4 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 sqtq #
Vector4 get sqtq => new Vector4(storage[0], storage[3], storage[1], storage[3]);
final Vector4 sqts #
Vector4 get sqts => new Vector4(storage[0], storage[3], storage[1], storage[0]);
final Vector4 sqtt #
Vector4 get sqtt => new Vector4(storage[0], storage[3], storage[1], storage[1]);
final Vector4 sspp #
Vector4 get sspp => new Vector4(storage[0], storage[0], storage[2], storage[2]);
final Vector4 sspq #
Vector4 get sspq => new Vector4(storage[0], storage[0], storage[2], storage[3]);
final Vector4 ssps #
Vector4 get ssps => new Vector4(storage[0], storage[0], storage[2], storage[0]);
final Vector4 sspt #
Vector4 get sspt => new Vector4(storage[0], storage[0], storage[2], storage[1]);
final Vector4 ssqp #
Vector4 get ssqp => new Vector4(storage[0], storage[0], storage[3], storage[2]);
final Vector4 ssqq #
Vector4 get ssqq => new Vector4(storage[0], storage[0], storage[3], storage[3]);
final Vector4 ssqs #
Vector4 get ssqs => new Vector4(storage[0], storage[0], storage[3], storage[0]);
final Vector4 ssqt #
Vector4 get ssqt => new Vector4(storage[0], storage[0], storage[3], storage[1]);
final Vector4 sssp #
Vector4 get sssp => new Vector4(storage[0], storage[0], storage[0], storage[2]);
final Vector4 sssq #
Vector4 get sssq => new Vector4(storage[0], storage[0], storage[0], storage[3]);
final Vector4 ssss #
Vector4 get ssss => new Vector4(storage[0], storage[0], storage[0], storage[0]);
final Vector4 ssst #
Vector4 get ssst => new Vector4(storage[0], storage[0], storage[0], storage[1]);
final Vector4 sstp #
Vector4 get sstp => new Vector4(storage[0], storage[0], storage[1], storage[2]);
final Vector4 sstq #
Vector4 get sstq => new Vector4(storage[0], storage[0], storage[1], storage[3]);
final Vector4 ssts #
Vector4 get ssts => new Vector4(storage[0], storage[0], storage[1], storage[0]);
final Vector4 sstt #
Vector4 get sstt => new Vector4(storage[0], storage[0], storage[1], storage[1]);
Vector2 st #
Vector2 get st => new Vector2(storage[0], storage[1]);
set st(Vector2 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; }
final Float32List storage #
final Float32List storage = new Float32List(4)
Vector3 stp #
Vector3 get stp => new Vector3(storage[0], storage[1], storage[2]);
set stp(Vector3 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 stpp #
Vector4 get stpp => new Vector4(storage[0], storage[1], storage[2], storage[2]);
Vector4 stpq #
Vector4 get stpq => new Vector4(storage[0], storage[1], storage[2], storage[3]);
set stpq(Vector4 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 stps #
Vector4 get stps => new Vector4(storage[0], storage[1], storage[2], storage[0]);
final Vector4 stpt #
Vector4 get stpt => new Vector4(storage[0], storage[1], storage[2], storage[1]);
Vector3 stq #
Vector3 get stq => new Vector3(storage[0], storage[1], storage[3]);
set stq(Vector3 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; }
Vector4 stqp #
Vector4 get stqp => new Vector4(storage[0], storage[1], storage[3], storage[2]);
set stqp(Vector4 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 stqq #
Vector4 get stqq => new Vector4(storage[0], storage[1], storage[3], storage[3]);
final Vector4 stqs #
Vector4 get stqs => new Vector4(storage[0], storage[1], storage[3], storage[0]);
final Vector4 stqt #
Vector4 get stqt => new Vector4(storage[0], storage[1], storage[3], storage[1]);
final Vector4 stsp #
Vector4 get stsp => new Vector4(storage[0], storage[1], storage[0], storage[2]);
final Vector4 stsq #
Vector4 get stsq => new Vector4(storage[0], storage[1], storage[0], storage[3]);
final Vector4 stss #
Vector4 get stss => new Vector4(storage[0], storage[1], storage[0], storage[0]);
final Vector4 stst #
Vector4 get stst => new Vector4(storage[0], storage[1], storage[0], storage[1]);
final Vector4 sttp #
Vector4 get sttp => new Vector4(storage[0], storage[1], storage[1], storage[2]);
final Vector4 sttq #
Vector4 get sttq => new Vector4(storage[0], storage[1], storage[1], storage[3]);
final Vector4 stts #
Vector4 get stts => new Vector4(storage[0], storage[1], storage[1], storage[0]);
final Vector4 sttt #
Vector4 get sttt => new Vector4(storage[0], storage[1], storage[1], storage[1]);
Vector2 tp #
Vector2 get tp => new Vector2(storage[1], storage[2]);
set tp(Vector2 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; }
final Vector4 tppp #
Vector4 get tppp => new Vector4(storage[1], storage[2], storage[2], storage[2]);
final Vector4 tppq #
Vector4 get tppq => new Vector4(storage[1], storage[2], storage[2], storage[3]);
final Vector4 tpps #
Vector4 get tpps => new Vector4(storage[1], storage[2], storage[2], storage[0]);
final Vector4 tppt #
Vector4 get tppt => new Vector4(storage[1], storage[2], storage[2], storage[1]);
Vector3 tpq #
Vector3 get tpq => new Vector3(storage[1], storage[2], storage[3]);
set tpq(Vector3 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 tpqp #
Vector4 get tpqp => new Vector4(storage[1], storage[2], storage[3], storage[2]);
final Vector4 tpqq #
Vector4 get tpqq => new Vector4(storage[1], storage[2], storage[3], storage[3]);
Vector4 tpqs #
Vector4 get tpqs => new Vector4(storage[1], storage[2], storage[3], storage[0]);
set tpqs(Vector4 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 tpqt #
Vector4 get tpqt => new Vector4(storage[1], storage[2], storage[3], storage[1]);
Vector3 tps #
Vector3 get tps => new Vector3(storage[1], storage[2], storage[0]);
set tps(Vector3 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 tpsp #
Vector4 get tpsp => new Vector4(storage[1], storage[2], storage[0], storage[2]);
Vector4 tpsq #
Vector4 get tpsq => new Vector4(storage[1], storage[2], storage[0], storage[3]);
set tpsq(Vector4 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 tpss #
Vector4 get tpss => new Vector4(storage[1], storage[2], storage[0], storage[0]);
final Vector4 tpst #
Vector4 get tpst => new Vector4(storage[1], storage[2], storage[0], storage[1]);
final Vector4 tptp #
Vector4 get tptp => new Vector4(storage[1], storage[2], storage[1], storage[2]);
final Vector4 tptq #
Vector4 get tptq => new Vector4(storage[1], storage[2], storage[1], storage[3]);
final Vector4 tpts #
Vector4 get tpts => new Vector4(storage[1], storage[2], storage[1], storage[0]);
final Vector4 tptt #
Vector4 get tptt => new Vector4(storage[1], storage[2], storage[1], storage[1]);
Vector2 tq #
Vector2 get tq => new Vector2(storage[1], storage[3]);
set tq(Vector2 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; }
Vector3 tqp #
Vector3 get tqp => new Vector3(storage[1], storage[3], storage[2]);
set tqp(Vector3 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 tqpp #
Vector4 get tqpp => new Vector4(storage[1], storage[3], storage[2], storage[2]);
final Vector4 tqpq #
Vector4 get tqpq => new Vector4(storage[1], storage[3], storage[2], storage[3]);
Vector4 tqps #
Vector4 get tqps => new Vector4(storage[1], storage[3], storage[2], storage[0]);
set tqps(Vector4 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 tqpt #
Vector4 get tqpt => new Vector4(storage[1], storage[3], storage[2], storage[1]);
final Vector4 tqqp #
Vector4 get tqqp => new Vector4(storage[1], storage[3], storage[3], storage[2]);
final Vector4 tqqq #
Vector4 get tqqq => new Vector4(storage[1], storage[3], storage[3], storage[3]);
final Vector4 tqqs #
Vector4 get tqqs => new Vector4(storage[1], storage[3], storage[3], storage[0]);
final Vector4 tqqt #
Vector4 get tqqt => new Vector4(storage[1], storage[3], storage[3], storage[1]);
Vector3 tqs #
Vector3 get tqs => new Vector3(storage[1], storage[3], storage[0]);
set tqs(Vector3 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; }
Vector4 tqsp #
Vector4 get tqsp => new Vector4(storage[1], storage[3], storage[0], storage[2]);
set tqsp(Vector4 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 tqsq #
Vector4 get tqsq => new Vector4(storage[1], storage[3], storage[0], storage[3]);
final Vector4 tqss #
Vector4 get tqss => new Vector4(storage[1], storage[3], storage[0], storage[0]);
final Vector4 tqst #
Vector4 get tqst => new Vector4(storage[1], storage[3], storage[0], storage[1]);
final Vector4 tqtp #
Vector4 get tqtp => new Vector4(storage[1], storage[3], storage[1], storage[2]);
final Vector4 tqtq #
Vector4 get tqtq => new Vector4(storage[1], storage[3], storage[1], storage[3]);
final Vector4 tqts #
Vector4 get tqts => new Vector4(storage[1], storage[3], storage[1], storage[0]);
final Vector4 tqtt #
Vector4 get tqtt => new Vector4(storage[1], storage[3], storage[1], storage[1]);
Vector2 ts #
Vector2 get ts => new Vector2(storage[1], storage[0]);
set ts(Vector2 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; }
Vector3 tsp #
Vector3 get tsp => new Vector3(storage[1], storage[0], storage[2]);
set tsp(Vector3 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 tspp #
Vector4 get tspp => new Vector4(storage[1], storage[0], storage[2], storage[2]);
Vector4 tspq #
Vector4 get tspq => new Vector4(storage[1], storage[0], storage[2], storage[3]);
set tspq(Vector4 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 tsps #
Vector4 get tsps => new Vector4(storage[1], storage[0], storage[2], storage[0]);
final Vector4 tspt #
Vector4 get tspt => new Vector4(storage[1], storage[0], storage[2], storage[1]);
Vector3 tsq #
Vector3 get tsq => new Vector3(storage[1], storage[0], storage[3]);
set tsq(Vector3 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; }
Vector4 tsqp #
Vector4 get tsqp => new Vector4(storage[1], storage[0], storage[3], storage[2]);
set tsqp(Vector4 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 tsqq #
Vector4 get tsqq => new Vector4(storage[1], storage[0], storage[3], storage[3]);
final Vector4 tsqs #
Vector4 get tsqs => new Vector4(storage[1], storage[0], storage[3], storage[0]);
final Vector4 tsqt #
Vector4 get tsqt => new Vector4(storage[1], storage[0], storage[3], storage[1]);
final Vector4 tssp #
Vector4 get tssp => new Vector4(storage[1], storage[0], storage[0], storage[2]);
final Vector4 tssq #
Vector4 get tssq => new Vector4(storage[1], storage[0], storage[0], storage[3]);
final Vector4 tsss #
Vector4 get tsss => new Vector4(storage[1], storage[0], storage[0], storage[0]);
final Vector4 tsst #
Vector4 get tsst => new Vector4(storage[1], storage[0], storage[0], storage[1]);
final Vector4 tstp #
Vector4 get tstp => new Vector4(storage[1], storage[0], storage[1], storage[2]);
final Vector4 tstq #
Vector4 get tstq => new Vector4(storage[1], storage[0], storage[1], storage[3]);
final Vector4 tsts #
Vector4 get tsts => new Vector4(storage[1], storage[0], storage[1], storage[0]);
final Vector4 tstt #
Vector4 get tstt => new Vector4(storage[1], storage[0], storage[1], storage[1]);
final Vector4 ttpp #
Vector4 get ttpp => new Vector4(storage[1], storage[1], storage[2], storage[2]);
final Vector4 ttpq #
Vector4 get ttpq => new Vector4(storage[1], storage[1], storage[2], storage[3]);
final Vector4 ttps #
Vector4 get ttps => new Vector4(storage[1], storage[1], storage[2], storage[0]);
final Vector4 ttpt #
Vector4 get ttpt => new Vector4(storage[1], storage[1], storage[2], storage[1]);
final Vector4 ttqp #
Vector4 get ttqp => new Vector4(storage[1], storage[1], storage[3], storage[2]);
final Vector4 ttqq #
Vector4 get ttqq => new Vector4(storage[1], storage[1], storage[3], storage[3]);
final Vector4 ttqs #
Vector4 get ttqs => new Vector4(storage[1], storage[1], storage[3], storage[0]);
final Vector4 ttqt #
Vector4 get ttqt => new Vector4(storage[1], storage[1], storage[3], storage[1]);
final Vector4 ttsp #
Vector4 get ttsp => new Vector4(storage[1], storage[1], storage[0], storage[2]);
final Vector4 ttsq #
Vector4 get ttsq => new Vector4(storage[1], storage[1], storage[0], storage[3]);
final Vector4 ttss #
Vector4 get ttss => new Vector4(storage[1], storage[1], storage[0], storage[0]);
final Vector4 ttst #
Vector4 get ttst => new Vector4(storage[1], storage[1], storage[0], storage[1]);
final Vector4 tttp #
Vector4 get tttp => new Vector4(storage[1], storage[1], storage[1], storage[2]);
final Vector4 tttq #
Vector4 get tttq => new Vector4(storage[1], storage[1], storage[1], storage[3]);
final Vector4 ttts #
Vector4 get ttts => new Vector4(storage[1], storage[1], storage[1], storage[0]);
final Vector4 tttt #
Vector4 get tttt => new Vector4(storage[1], storage[1], storage[1], storage[1]);
final Vector4 wwww #
Vector4 get wwww => new Vector4(storage[3], storage[3], storage[3], storage[3]);
final Vector4 wwwx #
Vector4 get wwwx => new Vector4(storage[3], storage[3], storage[3], storage[0]);
final Vector4 wwwy #
Vector4 get wwwy => new Vector4(storage[3], storage[3], storage[3], storage[1]);
final Vector4 wwwz #
Vector4 get wwwz => new Vector4(storage[3], storage[3], storage[3], storage[2]);
final Vector4 wwxw #
Vector4 get wwxw => new Vector4(storage[3], storage[3], storage[0], storage[3]);
final Vector4 wwxx #
Vector4 get wwxx => new Vector4(storage[3], storage[3], storage[0], storage[0]);
final Vector4 wwxy #
Vector4 get wwxy => new Vector4(storage[3], storage[3], storage[0], storage[1]);
final Vector4 wwxz #
Vector4 get wwxz => new Vector4(storage[3], storage[3], storage[0], storage[2]);
final Vector4 wwyw #
Vector4 get wwyw => new Vector4(storage[3], storage[3], storage[1], storage[3]);
final Vector4 wwyx #
Vector4 get wwyx => new Vector4(storage[3], storage[3], storage[1], storage[0]);
final Vector4 wwyy #
Vector4 get wwyy => new Vector4(storage[3], storage[3], storage[1], storage[1]);
final Vector4 wwyz #
Vector4 get wwyz => new Vector4(storage[3], storage[3], storage[1], storage[2]);
final Vector4 wwzw #
Vector4 get wwzw => new Vector4(storage[3], storage[3], storage[2], storage[3]);
final Vector4 wwzx #
Vector4 get wwzx => new Vector4(storage[3], storage[3], storage[2], storage[0]);
final Vector4 wwzy #
Vector4 get wwzy => new Vector4(storage[3], storage[3], storage[2], storage[1]);
final Vector4 wwzz #
Vector4 get wwzz => new Vector4(storage[3], storage[3], storage[2], storage[2]);
Vector2 wx #
Vector2 get wx => new Vector2(storage[3], storage[0]);
set wx(Vector2 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; }
final Vector4 wxww #
Vector4 get wxww => new Vector4(storage[3], storage[0], storage[3], storage[3]);
final Vector4 wxwx #
Vector4 get wxwx => new Vector4(storage[3], storage[0], storage[3], storage[0]);
final Vector4 wxwy #
Vector4 get wxwy => new Vector4(storage[3], storage[0], storage[3], storage[1]);
final Vector4 wxwz #
Vector4 get wxwz => new Vector4(storage[3], storage[0], storage[3], storage[2]);
final Vector4 wxxw #
Vector4 get wxxw => new Vector4(storage[3], storage[0], storage[0], storage[3]);
final Vector4 wxxx #
Vector4 get wxxx => new Vector4(storage[3], storage[0], storage[0], storage[0]);
final Vector4 wxxy #
Vector4 get wxxy => new Vector4(storage[3], storage[0], storage[0], storage[1]);
final Vector4 wxxz #
Vector4 get wxxz => new Vector4(storage[3], storage[0], storage[0], storage[2]);
Vector3 wxy #
Vector3 get wxy => new Vector3(storage[3], storage[0], storage[1]);
set wxy(Vector3 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 wxyw #
Vector4 get wxyw => new Vector4(storage[3], storage[0], storage[1], storage[3]);
final Vector4 wxyx #
Vector4 get wxyx => new Vector4(storage[3], storage[0], storage[1], storage[0]);
final Vector4 wxyy #
Vector4 get wxyy => new Vector4(storage[3], storage[0], storage[1], storage[1]);
Vector4 wxyz #
Vector4 get wxyz => new Vector4(storage[3], storage[0], storage[1], storage[2]);
set wxyz(Vector4 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; storage[2] = arg.storage[3]; }
Vector3 wxz #
Vector3 get wxz => new Vector3(storage[3], storage[0], storage[2]);
set wxz(Vector3 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 wxzw #
Vector4 get wxzw => new Vector4(storage[3], storage[0], storage[2], storage[3]);
final Vector4 wxzx #
Vector4 get wxzx => new Vector4(storage[3], storage[0], storage[2], storage[0]);
Vector4 wxzy #
Vector4 get wxzy => new Vector4(storage[3], storage[0], storage[2], storage[1]);
set wxzy(Vector4 arg) { storage[3] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 wxzz #
Vector4 get wxzz => new Vector4(storage[3], storage[0], storage[2], storage[2]);
Vector2 wy #
Vector2 get wy => new Vector2(storage[3], storage[1]);
set wy(Vector2 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; }
final Vector4 wyww #
Vector4 get wyww => new Vector4(storage[3], storage[1], storage[3], storage[3]);
final Vector4 wywx #
Vector4 get wywx => new Vector4(storage[3], storage[1], storage[3], storage[0]);
final Vector4 wywy #
Vector4 get wywy => new Vector4(storage[3], storage[1], storage[3], storage[1]);
final Vector4 wywz #
Vector4 get wywz => new Vector4(storage[3], storage[1], storage[3], storage[2]);
Vector3 wyx #
Vector3 get wyx => new Vector3(storage[3], storage[1], storage[0]);
set wyx(Vector3 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 wyxw #
Vector4 get wyxw => new Vector4(storage[3], storage[1], storage[0], storage[3]);
final Vector4 wyxx #
Vector4 get wyxx => new Vector4(storage[3], storage[1], storage[0], storage[0]);
final Vector4 wyxy #
Vector4 get wyxy => new Vector4(storage[3], storage[1], storage[0], storage[1]);
Vector4 wyxz #
Vector4 get wyxz => new Vector4(storage[3], storage[1], storage[0], storage[2]);
set wyxz(Vector4 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 wyyw #
Vector4 get wyyw => new Vector4(storage[3], storage[1], storage[1], storage[3]);
final Vector4 wyyx #
Vector4 get wyyx => new Vector4(storage[3], storage[1], storage[1], storage[0]);
final Vector4 wyyy #
Vector4 get wyyy => new Vector4(storage[3], storage[1], storage[1], storage[1]);
final Vector4 wyyz #
Vector4 get wyyz => new Vector4(storage[3], storage[1], storage[1], storage[2]);
Vector3 wyz #
Vector3 get wyz => new Vector3(storage[3], storage[1], storage[2]);
set wyz(Vector3 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 wyzw #
Vector4 get wyzw => new Vector4(storage[3], storage[1], storage[2], storage[3]);
Vector4 wyzx #
Vector4 get wyzx => new Vector4(storage[3], storage[1], storage[2], storage[0]);
set wyzx(Vector4 arg) { storage[3] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 wyzy #
Vector4 get wyzy => new Vector4(storage[3], storage[1], storage[2], storage[1]);
final Vector4 wyzz #
Vector4 get wyzz => new Vector4(storage[3], storage[1], storage[2], storage[2]);
Vector2 wz #
Vector2 get wz => new Vector2(storage[3], storage[2]);
set wz(Vector2 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; }
final Vector4 wzww #
Vector4 get wzww => new Vector4(storage[3], storage[2], storage[3], storage[3]);
final Vector4 wzwx #
Vector4 get wzwx => new Vector4(storage[3], storage[2], storage[3], storage[0]);
final Vector4 wzwy #
Vector4 get wzwy => new Vector4(storage[3], storage[2], storage[3], storage[1]);
final Vector4 wzwz #
Vector4 get wzwz => new Vector4(storage[3], storage[2], storage[3], storage[2]);
Vector3 wzx #
Vector3 get wzx => new Vector3(storage[3], storage[2], storage[0]);
set wzx(Vector3 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 wzxw #
Vector4 get wzxw => new Vector4(storage[3], storage[2], storage[0], storage[3]);
final Vector4 wzxx #
Vector4 get wzxx => new Vector4(storage[3], storage[2], storage[0], storage[0]);
Vector4 wzxy #
Vector4 get wzxy => new Vector4(storage[3], storage[2], storage[0], storage[1]);
set wzxy(Vector4 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 wzxz #
Vector4 get wzxz => new Vector4(storage[3], storage[2], storage[0], storage[2]);
Vector3 wzy #
Vector3 get wzy => new Vector3(storage[3], storage[2], storage[1]);
set wzy(Vector3 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 wzyw #
Vector4 get wzyw => new Vector4(storage[3], storage[2], storage[1], storage[3]);
Vector4 wzyx #
Vector4 get wzyx => new Vector4(storage[3], storage[2], storage[1], storage[0]);
set wzyx(Vector4 arg) { storage[3] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 wzyy #
Vector4 get wzyy => new Vector4(storage[3], storage[2], storage[1], storage[1]);
final Vector4 wzyz #
Vector4 get wzyz => new Vector4(storage[3], storage[2], storage[1], storage[2]);
final Vector4 wzzw #
Vector4 get wzzw => new Vector4(storage[3], storage[2], storage[2], storage[3]);
final Vector4 wzzx #
Vector4 get wzzx => new Vector4(storage[3], storage[2], storage[2], storage[0]);
final Vector4 wzzy #
Vector4 get wzzy => new Vector4(storage[3], storage[2], storage[2], storage[1]);
final Vector4 wzzz #
Vector4 get wzzz => new Vector4(storage[3], storage[2], storage[2], storage[2]);
Vector2 xw #
Vector2 get xw => new Vector2(storage[0], storage[3]);
set xw(Vector2 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; }
final Vector4 xwww #
Vector4 get xwww => new Vector4(storage[0], storage[3], storage[3], storage[3]);
final Vector4 xwwx #
Vector4 get xwwx => new Vector4(storage[0], storage[3], storage[3], storage[0]);
final Vector4 xwwy #
Vector4 get xwwy => new Vector4(storage[0], storage[3], storage[3], storage[1]);
final Vector4 xwwz #
Vector4 get xwwz => new Vector4(storage[0], storage[3], storage[3], storage[2]);
final Vector4 xwxw #
Vector4 get xwxw => new Vector4(storage[0], storage[3], storage[0], storage[3]);
final Vector4 xwxx #
Vector4 get xwxx => new Vector4(storage[0], storage[3], storage[0], storage[0]);
final Vector4 xwxy #
Vector4 get xwxy => new Vector4(storage[0], storage[3], storage[0], storage[1]);
final Vector4 xwxz #
Vector4 get xwxz => new Vector4(storage[0], storage[3], storage[0], storage[2]);
Vector3 xwy #
Vector3 get xwy => new Vector3(storage[0], storage[3], storage[1]);
set xwy(Vector3 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 xwyw #
Vector4 get xwyw => new Vector4(storage[0], storage[3], storage[1], storage[3]);
final Vector4 xwyx #
Vector4 get xwyx => new Vector4(storage[0], storage[3], storage[1], storage[0]);
final Vector4 xwyy #
Vector4 get xwyy => new Vector4(storage[0], storage[3], storage[1], storage[1]);
Vector4 xwyz #
Vector4 get xwyz => new Vector4(storage[0], storage[3], storage[1], storage[2]);
set xwyz(Vector4 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; storage[2] = arg.storage[3]; }
Vector3 xwz #
Vector3 get xwz => new Vector3(storage[0], storage[3], storage[2]);
set xwz(Vector3 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 xwzw #
Vector4 get xwzw => new Vector4(storage[0], storage[3], storage[2], storage[3]);
final Vector4 xwzx #
Vector4 get xwzx => new Vector4(storage[0], storage[3], storage[2], storage[0]);
Vector4 xwzy #
Vector4 get xwzy => new Vector4(storage[0], storage[3], storage[2], storage[1]);
set xwzy(Vector4 arg) { storage[0] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 xwzz #
Vector4 get xwzz => new Vector4(storage[0], storage[3], storage[2], storage[2]);
final Vector4 xxww #
Vector4 get xxww => new Vector4(storage[0], storage[0], storage[3], storage[3]);
final Vector4 xxwx #
Vector4 get xxwx => new Vector4(storage[0], storage[0], storage[3], storage[0]);
final Vector4 xxwy #
Vector4 get xxwy => new Vector4(storage[0], storage[0], storage[3], storage[1]);
final Vector4 xxwz #
Vector4 get xxwz => new Vector4(storage[0], storage[0], storage[3], storage[2]);
final Vector4 xxxw #
Vector4 get xxxw => new Vector4(storage[0], storage[0], storage[0], storage[3]);
final Vector4 xxxx #
Vector4 get xxxx => new Vector4(storage[0], storage[0], storage[0], storage[0]);
final Vector4 xxxy #
Vector4 get xxxy => new Vector4(storage[0], storage[0], storage[0], storage[1]);
final Vector4 xxxz #
Vector4 get xxxz => new Vector4(storage[0], storage[0], storage[0], storage[2]);
final Vector4 xxyw #
Vector4 get xxyw => new Vector4(storage[0], storage[0], storage[1], storage[3]);
final Vector4 xxyx #
Vector4 get xxyx => new Vector4(storage[0], storage[0], storage[1], storage[0]);
final Vector4 xxyy #
Vector4 get xxyy => new Vector4(storage[0], storage[0], storage[1], storage[1]);
final Vector4 xxyz #
Vector4 get xxyz => new Vector4(storage[0], storage[0], storage[1], storage[2]);
final Vector4 xxzw #
Vector4 get xxzw => new Vector4(storage[0], storage[0], storage[2], storage[3]);
final Vector4 xxzx #
Vector4 get xxzx => new Vector4(storage[0], storage[0], storage[2], storage[0]);
final Vector4 xxzy #
Vector4 get xxzy => new Vector4(storage[0], storage[0], storage[2], storage[1]);
final Vector4 xxzz #
Vector4 get xxzz => new Vector4(storage[0], storage[0], storage[2], storage[2]);
Vector2 xy #
Vector2 get xy => new Vector2(storage[0], storage[1]);
set xy(Vector2 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; }
Vector3 xyw #
Vector3 get xyw => new Vector3(storage[0], storage[1], storage[3]);
set xyw(Vector3 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 xyww #
Vector4 get xyww => new Vector4(storage[0], storage[1], storage[3], storage[3]);
final Vector4 xywx #
Vector4 get xywx => new Vector4(storage[0], storage[1], storage[3], storage[0]);
final Vector4 xywy #
Vector4 get xywy => new Vector4(storage[0], storage[1], storage[3], storage[1]);
Vector4 xywz #
Vector4 get xywz => new Vector4(storage[0], storage[1], storage[3], storage[2]);
set xywz(Vector4 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 xyxw #
Vector4 get xyxw => new Vector4(storage[0], storage[1], storage[0], storage[3]);
final Vector4 xyxx #
Vector4 get xyxx => new Vector4(storage[0], storage[1], storage[0], storage[0]);
final Vector4 xyxy #
Vector4 get xyxy => new Vector4(storage[0], storage[1], storage[0], storage[1]);
final Vector4 xyxz #
Vector4 get xyxz => new Vector4(storage[0], storage[1], storage[0], storage[2]);
final Vector4 xyyw #
Vector4 get xyyw => new Vector4(storage[0], storage[1], storage[1], storage[3]);
final Vector4 xyyx #
Vector4 get xyyx => new Vector4(storage[0], storage[1], storage[1], storage[0]);
final Vector4 xyyy #
Vector4 get xyyy => new Vector4(storage[0], storage[1], storage[1], storage[1]);
final Vector4 xyyz #
Vector4 get xyyz => new Vector4(storage[0], storage[1], storage[1], storage[2]);
Vector3 xyz #
Vector3 get xyz => new Vector3(storage[0], storage[1], storage[2]);
set xyz(Vector3 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; }
Vector4 xyzw #
Vector4 get xyzw => new Vector4(storage[0], storage[1], storage[2], storage[3]);
set xyzw(Vector4 arg) { storage[0] = arg.storage[0]; storage[1] = arg.storage[1]; storage[2] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 xyzx #
Vector4 get xyzx => new Vector4(storage[0], storage[1], storage[2], storage[0]);
final Vector4 xyzy #
Vector4 get xyzy => new Vector4(storage[0], storage[1], storage[2], storage[1]);
final Vector4 xyzz #
Vector4 get xyzz => new Vector4(storage[0], storage[1], storage[2], storage[2]);
Vector2 xz #
Vector2 get xz => new Vector2(storage[0], storage[2]);
set xz(Vector2 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; }
Vector3 xzw #
Vector3 get xzw => new Vector3(storage[0], storage[2], storage[3]);
set xzw(Vector3 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 xzww #
Vector4 get xzww => new Vector4(storage[0], storage[2], storage[3], storage[3]);
final Vector4 xzwx #
Vector4 get xzwx => new Vector4(storage[0], storage[2], storage[3], storage[0]);
Vector4 xzwy #
Vector4 get xzwy => new Vector4(storage[0], storage[2], storage[3], storage[1]);
set xzwy(Vector4 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 xzwz #
Vector4 get xzwz => new Vector4(storage[0], storage[2], storage[3], storage[2]);
final Vector4 xzxw #
Vector4 get xzxw => new Vector4(storage[0], storage[2], storage[0], storage[3]);
final Vector4 xzxx #
Vector4 get xzxx => new Vector4(storage[0], storage[2], storage[0], storage[0]);
final Vector4 xzxy #
Vector4 get xzxy => new Vector4(storage[0], storage[2], storage[0], storage[1]);
final Vector4 xzxz #
Vector4 get xzxz => new Vector4(storage[0], storage[2], storage[0], storage[2]);
Vector3 xzy #
Vector3 get xzy => new Vector3(storage[0], storage[2], storage[1]);
set xzy(Vector3 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; }
Vector4 xzyw #
Vector4 get xzyw => new Vector4(storage[0], storage[2], storage[1], storage[3]);
set xzyw(Vector4 arg) { storage[0] = arg.storage[0]; storage[2] = arg.storage[1]; storage[1] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 xzyx #
Vector4 get xzyx => new Vector4(storage[0], storage[2], storage[1], storage[0]);
final Vector4 xzyy #
Vector4 get xzyy => new Vector4(storage[0], storage[2], storage[1], storage[1]);
final Vector4 xzyz #
Vector4 get xzyz => new Vector4(storage[0], storage[2], storage[1], storage[2]);
final Vector4 xzzw #
Vector4 get xzzw => new Vector4(storage[0], storage[2], storage[2], storage[3]);
final Vector4 xzzx #
Vector4 get xzzx => new Vector4(storage[0], storage[2], storage[2], storage[0]);
final Vector4 xzzy #
Vector4 get xzzy => new Vector4(storage[0], storage[2], storage[2], storage[1]);
final Vector4 xzzz #
Vector4 get xzzz => new Vector4(storage[0], storage[2], storage[2], storage[2]);
Vector2 yw #
Vector2 get yw => new Vector2(storage[1], storage[3]);
set yw(Vector2 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; }
final Vector4 ywww #
Vector4 get ywww => new Vector4(storage[1], storage[3], storage[3], storage[3]);
final Vector4 ywwx #
Vector4 get ywwx => new Vector4(storage[1], storage[3], storage[3], storage[0]);
final Vector4 ywwy #
Vector4 get ywwy => new Vector4(storage[1], storage[3], storage[3], storage[1]);
final Vector4 ywwz #
Vector4 get ywwz => new Vector4(storage[1], storage[3], storage[3], storage[2]);
Vector3 ywx #
Vector3 get ywx => new Vector3(storage[1], storage[3], storage[0]);
set ywx(Vector3 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 ywxw #
Vector4 get ywxw => new Vector4(storage[1], storage[3], storage[0], storage[3]);
final Vector4 ywxx #
Vector4 get ywxx => new Vector4(storage[1], storage[3], storage[0], storage[0]);
final Vector4 ywxy #
Vector4 get ywxy => new Vector4(storage[1], storage[3], storage[0], storage[1]);
Vector4 ywxz #
Vector4 get ywxz => new Vector4(storage[1], storage[3], storage[0], storage[2]);
set ywxz(Vector4 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 ywyw #
Vector4 get ywyw => new Vector4(storage[1], storage[3], storage[1], storage[3]);
final Vector4 ywyx #
Vector4 get ywyx => new Vector4(storage[1], storage[3], storage[1], storage[0]);
final Vector4 ywyy #
Vector4 get ywyy => new Vector4(storage[1], storage[3], storage[1], storage[1]);
final Vector4 ywyz #
Vector4 get ywyz => new Vector4(storage[1], storage[3], storage[1], storage[2]);
Vector3 ywz #
Vector3 get ywz => new Vector3(storage[1], storage[3], storage[2]);
set ywz(Vector3 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; }
final Vector4 ywzw #
Vector4 get ywzw => new Vector4(storage[1], storage[3], storage[2], storage[3]);
Vector4 ywzx #
Vector4 get ywzx => new Vector4(storage[1], storage[3], storage[2], storage[0]);
set ywzx(Vector4 arg) { storage[1] = arg.storage[0]; storage[3] = arg.storage[1]; storage[2] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 ywzy #
Vector4 get ywzy => new Vector4(storage[1], storage[3], storage[2], storage[1]);
final Vector4 ywzz #
Vector4 get ywzz => new Vector4(storage[1], storage[3], storage[2], storage[2]);
Vector2 yx #
Vector2 get yx => new Vector2(storage[1], storage[0]);
set yx(Vector2 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; }
Vector3 yxw #
Vector3 get yxw => new Vector3(storage[1], storage[0], storage[3]);
set yxw(Vector3 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 yxww #
Vector4 get yxww => new Vector4(storage[1], storage[0], storage[3], storage[3]);
final Vector4 yxwx #
Vector4 get yxwx => new Vector4(storage[1], storage[0], storage[3], storage[0]);
final Vector4 yxwy #
Vector4 get yxwy => new Vector4(storage[1], storage[0], storage[3], storage[1]);
Vector4 yxwz #
Vector4 get yxwz => new Vector4(storage[1], storage[0], storage[3], storage[2]);
set yxwz(Vector4 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; storage[2] = arg.storage[3]; }
final Vector4 yxxw #
Vector4 get yxxw => new Vector4(storage[1], storage[0], storage[0], storage[3]);
final Vector4 yxxx #
Vector4 get yxxx => new Vector4(storage[1], storage[0], storage[0], storage[0]);
final Vector4 yxxy #
Vector4 get yxxy => new Vector4(storage[1], storage[0], storage[0], storage[1]);
final Vector4 yxxz #
Vector4 get yxxz => new Vector4(storage[1], storage[0], storage[0], storage[2]);
final Vector4 yxyw #
Vector4 get yxyw => new Vector4(storage[1], storage[0], storage[1], storage[3]);
final Vector4 yxyx #
Vector4 get yxyx => new Vector4(storage[1], storage[0], storage[1], storage[0]);
final Vector4 yxyy #
Vector4 get yxyy => new Vector4(storage[1], storage[0], storage[1], storage[1]);
final Vector4 yxyz #
Vector4 get yxyz => new Vector4(storage[1], storage[0], storage[1], storage[2]);
Vector3 yxz #
Vector3 get yxz => new Vector3(storage[1], storage[0], storage[2]);
set yxz(Vector3 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; }
Vector4 yxzw #
Vector4 get yxzw => new Vector4(storage[1], storage[0], storage[2], storage[3]);
set yxzw(Vector4 arg) { storage[1] = arg.storage[0]; storage[0] = arg.storage[1]; storage[2] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 yxzx #
Vector4 get yxzx => new Vector4(storage[1], storage[0], storage[2], storage[0]);
final Vector4 yxzy #
Vector4 get yxzy => new Vector4(storage[1], storage[0], storage[2], storage[1]);
final Vector4 yxzz #
Vector4 get yxzz => new Vector4(storage[1], storage[0], storage[2], storage[2]);
final Vector4 yyww #
Vector4 get yyww => new Vector4(storage[1], storage[1], storage[3], storage[3]);
final Vector4 yywx #
Vector4 get yywx => new Vector4(storage[1], storage[1], storage[3], storage[0]);
final Vector4 yywy #
Vector4 get yywy => new Vector4(storage[1], storage[1], storage[3], storage[1]);
final Vector4 yywz #
Vector4 get yywz => new Vector4(storage[1], storage[1], storage[3], storage[2]);
final Vector4 yyxw #
Vector4 get yyxw => new Vector4(storage[1], storage[1], storage[0], storage[3]);
final Vector4 yyxx #
Vector4 get yyxx => new Vector4(storage[1], storage[1], storage[0], storage[0]);
final Vector4 yyxy #
Vector4 get yyxy => new Vector4(storage[1], storage[1], storage[0], storage[1]);
final Vector4 yyxz #
Vector4 get yyxz => new Vector4(storage[1], storage[1], storage[0], storage[2]);
final Vector4 yyyw #
Vector4 get yyyw => new Vector4(storage[1], storage[1], storage[1], storage[3]);
final Vector4 yyyx #
Vector4 get yyyx => new Vector4(storage[1], storage[1], storage[1], storage[0]);
final Vector4 yyyy #
Vector4 get yyyy => new Vector4(storage[1], storage[1], storage[1], storage[1]);
final Vector4 yyyz #
Vector4 get yyyz => new Vector4(storage[1], storage[1], storage[1], storage[2]);
final Vector4 yyzw #
Vector4 get yyzw => new Vector4(storage[1], storage[1], storage[2], storage[3]);
final Vector4 yyzx #
Vector4 get yyzx => new Vector4(storage[1], storage[1], storage[2], storage[0]);
final Vector4 yyzy #
Vector4 get yyzy => new Vector4(storage[1], storage[1], storage[2], storage[1]);
final Vector4 yyzz #
Vector4 get yyzz => new Vector4(storage[1], storage[1], storage[2], storage[2]);
Vector2 yz #
Vector2 get yz => new Vector2(storage[1], storage[2]);
set yz(Vector2 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; }
Vector3 yzw #
Vector3 get yzw => new Vector3(storage[1], storage[2], storage[3]);
set yzw(Vector3 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 yzww #
Vector4 get yzww => new Vector4(storage[1], storage[2], storage[3], storage[3]);
Vector4 yzwx #
Vector4 get yzwx => new Vector4(storage[1], storage[2], storage[3], storage[0]);
set yzwx(Vector4 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[3] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 yzwy #
Vector4 get yzwy => new Vector4(storage[1], storage[2], storage[3], storage[1]);
final Vector4 yzwz #
Vector4 get yzwz => new Vector4(storage[1], storage[2], storage[3], storage[2]);
Vector3 yzx #
Vector3 get yzx => new Vector3(storage[1], storage[2], storage[0]);
set yzx(Vector3 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; }
Vector4 yzxw #
Vector4 get yzxw => new Vector4(storage[1], storage[2], storage[0], storage[3]);
set yzxw(Vector4 arg) { storage[1] = arg.storage[0]; storage[2] = arg.storage[1]; storage[0] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 yzxx #
Vector4 get yzxx => new Vector4(storage[1], storage[2], storage[0], storage[0]);
final Vector4 yzxy #
Vector4 get yzxy => new Vector4(storage[1], storage[2], storage[0], storage[1]);
final Vector4 yzxz #
Vector4 get yzxz => new Vector4(storage[1], storage[2], storage[0], storage[2]);
final Vector4 yzyw #
Vector4 get yzyw => new Vector4(storage[1], storage[2], storage[1], storage[3]);
final Vector4 yzyx #
Vector4 get yzyx => new Vector4(storage[1], storage[2], storage[1], storage[0]);
final Vector4 yzyy #
Vector4 get yzyy => new Vector4(storage[1], storage[2], storage[1], storage[1]);
final Vector4 yzyz #
Vector4 get yzyz => new Vector4(storage[1], storage[2], storage[1], storage[2]);
final Vector4 yzzw #
Vector4 get yzzw => new Vector4(storage[1], storage[2], storage[2], storage[3]);
final Vector4 yzzx #
Vector4 get yzzx => new Vector4(storage[1], storage[2], storage[2], storage[0]);
final Vector4 yzzy #
Vector4 get yzzy => new Vector4(storage[1], storage[2], storage[2], storage[1]);
final Vector4 yzzz #
Vector4 get yzzz => new Vector4(storage[1], storage[2], storage[2], storage[2]);
Vector2 zw #
Vector2 get zw => new Vector2(storage[2], storage[3]);
set zw(Vector2 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; }
final Vector4 zwww #
Vector4 get zwww => new Vector4(storage[2], storage[3], storage[3], storage[3]);
final Vector4 zwwx #
Vector4 get zwwx => new Vector4(storage[2], storage[3], storage[3], storage[0]);
final Vector4 zwwy #
Vector4 get zwwy => new Vector4(storage[2], storage[3], storage[3], storage[1]);
final Vector4 zwwz #
Vector4 get zwwz => new Vector4(storage[2], storage[3], storage[3], storage[2]);
Vector3 zwx #
Vector3 get zwx => new Vector3(storage[2], storage[3], storage[0]);
set zwx(Vector3 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; }
final Vector4 zwxw #
Vector4 get zwxw => new Vector4(storage[2], storage[3], storage[0], storage[3]);
final Vector4 zwxx #
Vector4 get zwxx => new Vector4(storage[2], storage[3], storage[0], storage[0]);
Vector4 zwxy #
Vector4 get zwxy => new Vector4(storage[2], storage[3], storage[0], storage[1]);
set zwxy(Vector4 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[0] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 zwxz #
Vector4 get zwxz => new Vector4(storage[2], storage[3], storage[0], storage[2]);
Vector3 zwy #
Vector3 get zwy => new Vector3(storage[2], storage[3], storage[1]);
set zwy(Vector3 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; }
final Vector4 zwyw #
Vector4 get zwyw => new Vector4(storage[2], storage[3], storage[1], storage[3]);
Vector4 zwyx #
Vector4 get zwyx => new Vector4(storage[2], storage[3], storage[1], storage[0]);
set zwyx(Vector4 arg) { storage[2] = arg.storage[0]; storage[3] = arg.storage[1]; storage[1] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 zwyy #
Vector4 get zwyy => new Vector4(storage[2], storage[3], storage[1], storage[1]);
final Vector4 zwyz #
Vector4 get zwyz => new Vector4(storage[2], storage[3], storage[1], storage[2]);
final Vector4 zwzw #
Vector4 get zwzw => new Vector4(storage[2], storage[3], storage[2], storage[3]);
final Vector4 zwzx #
Vector4 get zwzx => new Vector4(storage[2], storage[3], storage[2], storage[0]);
final Vector4 zwzy #
Vector4 get zwzy => new Vector4(storage[2], storage[3], storage[2], storage[1]);
final Vector4 zwzz #
Vector4 get zwzz => new Vector4(storage[2], storage[3], storage[2], storage[2]);
Vector2 zx #
Vector2 get zx => new Vector2(storage[2], storage[0]);
set zx(Vector2 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; }
Vector3 zxw #
Vector3 get zxw => new Vector3(storage[2], storage[0], storage[3]);
set zxw(Vector3 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 zxww #
Vector4 get zxww => new Vector4(storage[2], storage[0], storage[3], storage[3]);
final Vector4 zxwx #
Vector4 get zxwx => new Vector4(storage[2], storage[0], storage[3], storage[0]);
Vector4 zxwy #
Vector4 get zxwy => new Vector4(storage[2], storage[0], storage[3], storage[1]);
set zxwy(Vector4 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[3] = arg.storage[2]; storage[1] = arg.storage[3]; }
final Vector4 zxwz #
Vector4 get zxwz => new Vector4(storage[2], storage[0], storage[3], storage[2]);
final Vector4 zxxw #
Vector4 get zxxw => new Vector4(storage[2], storage[0], storage[0], storage[3]);
final Vector4 zxxx #
Vector4 get zxxx => new Vector4(storage[2], storage[0], storage[0], storage[0]);
final Vector4 zxxy #
Vector4 get zxxy => new Vector4(storage[2], storage[0], storage[0], storage[1]);
final Vector4 zxxz #
Vector4 get zxxz => new Vector4(storage[2], storage[0], storage[0], storage[2]);
Vector3 zxy #
Vector3 get zxy => new Vector3(storage[2], storage[0], storage[1]);
set zxy(Vector3 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; }
Vector4 zxyw #
Vector4 get zxyw => new Vector4(storage[2], storage[0], storage[1], storage[3]);
set zxyw(Vector4 arg) { storage[2] = arg.storage[0]; storage[0] = arg.storage[1]; storage[1] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 zxyx #
Vector4 get zxyx => new Vector4(storage[2], storage[0], storage[1], storage[0]);
final Vector4 zxyy #
Vector4 get zxyy => new Vector4(storage[2], storage[0], storage[1], storage[1]);
final Vector4 zxyz #
Vector4 get zxyz => new Vector4(storage[2], storage[0], storage[1], storage[2]);
final Vector4 zxzw #
Vector4 get zxzw => new Vector4(storage[2], storage[0], storage[2], storage[3]);
final Vector4 zxzx #
Vector4 get zxzx => new Vector4(storage[2], storage[0], storage[2], storage[0]);
final Vector4 zxzy #
Vector4 get zxzy => new Vector4(storage[2], storage[0], storage[2], storage[1]);
final Vector4 zxzz #
Vector4 get zxzz => new Vector4(storage[2], storage[0], storage[2], storage[2]);
Vector2 zy #
Vector2 get zy => new Vector2(storage[2], storage[1]);
set zy(Vector2 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; }
Vector3 zyw #
Vector3 get zyw => new Vector3(storage[2], storage[1], storage[3]);
set zyw(Vector3 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; }
final Vector4 zyww #
Vector4 get zyww => new Vector4(storage[2], storage[1], storage[3], storage[3]);
Vector4 zywx #
Vector4 get zywx => new Vector4(storage[2], storage[1], storage[3], storage[0]);
set zywx(Vector4 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[3] = arg.storage[2]; storage[0] = arg.storage[3]; }
final Vector4 zywy #
Vector4 get zywy => new Vector4(storage[2], storage[1], storage[3], storage[1]);
final Vector4 zywz #
Vector4 get zywz => new Vector4(storage[2], storage[1], storage[3], storage[2]);
Vector3 zyx #
Vector3 get zyx => new Vector3(storage[2], storage[1], storage[0]);
set zyx(Vector3 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; }
Vector4 zyxw #
Vector4 get zyxw => new Vector4(storage[2], storage[1], storage[0], storage[3]);
set zyxw(Vector4 arg) { storage[2] = arg.storage[0]; storage[1] = arg.storage[1]; storage[0] = arg.storage[2]; storage[3] = arg.storage[3]; }
final Vector4 zyxx #
Vector4 get zyxx => new Vector4(storage[2], storage[1], storage[0], storage[0]);
final Vector4 zyxy #
Vector4 get zyxy => new Vector4(storage[2], storage[1], storage[0], storage[1]);
final Vector4 zyxz #
Vector4 get zyxz => new Vector4(storage[2], storage[1], storage[0], storage[2]);
final Vector4 zyyw #
Vector4 get zyyw => new Vector4(storage[2], storage[1], storage[1], storage[3]);
final Vector4 zyyx #
Vector4 get zyyx => new Vector4(storage[2], storage[1], storage[1], storage[0]);
final Vector4 zyyy #
Vector4 get zyyy => new Vector4(storage[2], storage[1], storage[1], storage[1]);
final Vector4 zyyz #
Vector4 get zyyz => new Vector4(storage[2], storage[1], storage[1], storage[2]);
final Vector4 zyzw #
Vector4 get zyzw => new Vector4(storage[2], storage[1], storage[2], storage[3]);
final Vector4 zyzx #
Vector4 get zyzx => new Vector4(storage[2], storage[1], storage[2], storage[0]);
final Vector4 zyzy #
Vector4 get zyzy => new Vector4(storage[2], storage[1], storage[2], storage[1]);
final Vector4 zyzz #
Vector4 get zyzz => new Vector4(storage[2], storage[1], storage[2], storage[2]);
final Vector4 zzww #
Vector4 get zzww => new Vector4(storage[2], storage[2], storage[3], storage[3]);
final Vector4 zzwx #
Vector4 get zzwx => new Vector4(storage[2], storage[2], storage[3], storage[0]);
final Vector4 zzwy #
Vector4 get zzwy => new Vector4(storage[2], storage[2], storage[3], storage[1]);
final Vector4 zzwz #
Vector4 get zzwz => new Vector4(storage[2], storage[2], storage[3], storage[2]);
final Vector4 zzxw #
Vector4 get zzxw => new Vector4(storage[2], storage[2], storage[0], storage[3]);
final Vector4 zzxx #
Vector4 get zzxx => new Vector4(storage[2], storage[2], storage[0], storage[0]);
final Vector4 zzxy #
Vector4 get zzxy => new Vector4(storage[2], storage[2], storage[0], storage[1]);
final Vector4 zzxz #
Vector4 get zzxz => new Vector4(storage[2], storage[2], storage[0], storage[2]);
final Vector4 zzyw #
Vector4 get zzyw => new Vector4(storage[2], storage[2], storage[1], storage[3]);
final Vector4 zzyx #
Vector4 get zzyx => new Vector4(storage[2], storage[2], storage[1], storage[0]);
final Vector4 zzyy #
Vector4 get zzyy => new Vector4(storage[2], storage[2], storage[1], storage[1]);
final Vector4 zzyz #
Vector4 get zzyz => new Vector4(storage[2], storage[2], storage[1], storage[2]);
final Vector4 zzzw #
Vector4 get zzzw => new Vector4(storage[2], storage[2], storage[2], storage[3]);
final Vector4 zzzx #
Vector4 get zzzx => new Vector4(storage[2], storage[2], storage[2], storage[0]);
Operators
Vector4 operator +(Vector4 other) #
Add two vectors.
Vector4 operator+(Vector4 other) => new Vector4(storage[0] + other.storage[0], storage[1] + other.storage[1], storage[2] + other.storage[2], storage[3] + other.storage[3]);
Vector4 operator -() #
Negate.
Vector4 operator-() => new Vector4(-storage[0], -storage[1], -storage[2], -storage[3]);
Vector4 operator -(Vector4 other) #
Subtract two vectors.
Vector4 operator-(Vector4 other) => new Vector4(storage[0] - other.storage[0], storage[1] - other.storage[1], storage[2] - other.storage[2], storage[3] - other.storage[3]);
Methods
Vector4 absolute() #
Vector4 absolute() { storage[3] = storage[3].abs(); storage[2] = storage[2].abs(); storage[1] = storage[1].abs(); storage[0] = storage[0].abs(); return this; }
double absoluteError(Vector4 correct) #
Absolute error between this
and
correct
double absoluteError(Vector4 correct) { return (this - correct).length; }
Vector4 add(Vector4 arg) #
Vector4 add(Vector4 arg) { storage[0] = storage[0] + arg.storage[0]; storage[1] = storage[1] + arg.storage[1]; storage[2] = storage[2] + arg.storage[2]; storage[3] = storage[3] + arg.storage[3]; return this; }
void copyFromArray(List<double> array, [int offset = 0]) #
Copies elements from
array into this
starting at
offset.
void copyFromArray(List<double> array, [int offset=0]) { storage[0] = array[offset+0]; storage[1] = array[offset+1]; storage[2] = array[offset+2]; storage[3] = array[offset+3]; }
Vector4 copyInto(Vector4 arg) #
Vector4 copyInto(Vector4 arg) { arg.storage[0] = storage[0]; arg.storage[1] = storage[1]; arg.storage[2] = storage[2]; arg.storage[3] = storage[3]; return arg; }
void copyIntoArray(List<double> array, [int offset = 0]) #
Copies this
into
array starting at
offset.
void copyIntoArray(List<double> array, [int offset=0]) { array[offset+0] = storage[0]; array[offset+1] = storage[1]; array[offset+2] = storage[2]; array[offset+3] = storage[3]; }
Vector4 div(Vector4 arg) #
Vector4 div(Vector4 arg) { storage[0] = storage[0] / arg.storage[0]; storage[1] = storage[1] / arg.storage[1]; storage[2] = storage[2] / arg.storage[2]; storage[3] = storage[3] / arg.storage[3]; return this; }
double dot(Vector4 other) #
Inner product.
double dot(Vector4 other) { double sum; sum = storage[0] * other.storage[0]; sum += storage[1] * other.storage[1]; sum += storage[2] * other.storage[2]; sum += storage[3] * other.storage[3]; return sum; }
Vector4 multiply(Vector4 arg) #
Vector4 multiply(Vector4 arg) { storage[0] = storage[0] * arg.storage[0]; storage[1] = storage[1] * arg.storage[1]; storage[2] = storage[2] * arg.storage[2]; storage[3] = storage[3] * arg.storage[3]; return this; }
Vector4 negate() #
Vector4 negate() { storage[0] = -storage[0]; storage[1] = -storage[1]; storage[2] = -storage[2]; storage[3] = -storage[3]; return this; }
Vector4 normalize() #
Normalizes this
.
Vector4 normalize() { double l = length; // TODO(johnmccutchan): Use an epsilon. if (l == 0.0) { return this; } l = 1.0 / l; storage[0] *= l; storage[1] *= l; storage[2] *= l; storage[3] *= l; return this; }
Vector4 normalized() #
Normalizes copy of this
.
Vector4 normalized() { return new Vector4.copy(this).normalize(); }
Vector4 normalizeInto(Vector4 out) #
Normalize vector into out.
Vector4 normalizeInto(Vector4 out) { out.setFrom(this); return out.normalize(); }
double normalizeLength() #
Normalizes this
. Returns length of vector before normalization.
double normalizeLength() { double l = length; if (l == 0.0) { return 0.0; } l = 1.0 / l; storage[0] *= l; storage[1] *= l; storage[2] *= l; storage[3] *= l; return l; }
double relativeError(Vector4 correct) #
Relative error between this
and
correct
double relativeError(Vector4 correct) { double correct_norm = correct.length; double diff_norm = (this - correct).length; return diff_norm/correct_norm; }
Vector4 scale(double arg) #
Vector4 scale(double arg) { storage[0] = storage[0] * arg; storage[1] = storage[1] * arg; storage[2] = storage[2] * arg; storage[3] = storage[3] * arg; return this; }
Vector4 setFrom(Vector4 other) #
Set the values by copying them from other.
Vector4 setFrom(Vector4 other) { storage[3] = other.storage[3]; storage[2] = other.storage[2]; storage[1] = other.storage[1]; storage[0] = other.storage[0]; return this; }
Vector4 setValues(double x_, double y_, double z_, double w_) #
Set the values of the vector.
Vector4 setValues(double x_, double y_, double z_, double w_) { storage[3] = w_; storage[2] = z_; storage[1] = y_; storage[0] = x_; return this; }
Vector4 setZero() #
Zero the vector.
Vector4 setZero() { storage[0] = 0.0; storage[1] = 0.0; storage[2] = 0.0; storage[3] = 0.0; return this; }
Vector4 splat(double arg) #
Splat arg into all lanes of the vector.
Vector4 splat(double arg) { storage[3] = arg; storage[2] = arg; storage[1] = arg; storage[0] = arg; return this; }


* Those content are supposed to be the best for helping you to revise your vocabulary. The number shown in front of each title indicates how strongly fixed are the content words in your memory, based on your previous readings / watching.
Sorry, computing recommendations is a long task! Thank you for waiting!
* A percentage of 50% means that you know 50% of the words used
Sorry, computing recommendations is a long task! Thank you for waiting!
* A percentage of 50% means that you know 50% of the words used
Sorry, computing recommendations is a long task! Thank you for waiting!


HEAT A film review by Christopher Null Copyright 1995 Christopher Null
I hate to condone the making of 3-hour long movies, but HEAT is one in which you're not going to fall asleep. Comparisons to CASINO are going to be inevitable, with both hitting the 180-minute mark and starring Robert DeNiro as a crook, but unlike that film, HEAT manages to keep the interest level high throughout the whole picture.
HEAT is the instantly gripping tale of a large-scale heist leader and die-hard loner named Neil McCauley (DeNiro). As the film opens, he and his team of brutal, precision thieves (including Val Kilmer and Tom Sizemore) knock over (literally) an armored car for a stash of bearer bonds. On the case is Detective Vincent Hanna (Al Pacino), a troubled, angst-ridden veteran of the LAPD. Over the course of the film, McCauley and Hanna develop a strange sort of kinship, even as McCauley's crimes increasingly raise the stakes and Hanna's efforts to stop him become more and more desperate.
The action builds up for a solid two hours until a nearly catastrophic "final" bank robbery results in one of the most vivid shoot-outs ever filmed. Writer/director Michael Mann (best known for his work on "Miami Vice") paces the movie well, and he really puts the audience through the ringer by getting the adrenaline pumping like an oil well.
But why is this film 3 hours long, you ask? The answer lies in Mann's multidimensional examinations of all the major characters, their wives, their children, and any other love interests who happen along. Thus over the course of the picture, we discover Hanna is in his third marriage and his wife's ex-husband is a deadbeat. We learn at length about McCauley's personal code: to have nothing in his life he can't walk away from in 30 seconds flat if "the heat" is coming. And when the heat does come, we see how it affects everyone...in depth. While these relationship subplots are mildly interesting, they seem completely out of place in the movie and, in the end, weigh the film down.
This aside, strong performances by the principals and some excellent bit parts by players like Hank Azaria, Tom Noonan, Natalie Portman, and Jon Voight make HEAT a truly memorable film. Somewhat more difficult to figure out is Pacino, who takes his over-the-top, in-your-face screen presence to new heights, becoming almost cartoonish in his archetypal portrayal of the insanely driven cop. Altogether, the cast lends a lot of credibility to what would otherwise be another run-of-the-mill crime movie. And while the sometimes hard-to-follow script often demands too much of the viewer, this film is one that's truly worth seeing.
RATING: ****
\-------------------------------\ |* Unquestionably awful | |** Sub-par on many levels | |*** Average, hits and misses | |**** Good, memorable film | |***** Perfection | \-------------------------------\
-Christopher Null /<EMAIL_ADDRESS>-Movie Emporium (reviews) / http://www.notes.tpoint.net/emporium/ -Contributing Editor, FEEDBACK / http://www.eden.com/~feedback/ -E-mail requests to join the movie review mailing list
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Get a list of events for an issue or pull request.
Custom media type: mockingbird-preview Announced: 2016-05-23
mockingbird-preview


EXPERIENCE:
Software Engineer - Angular, Python, Django, Postgres, LESS, Heroku
Jul 2016 - Present
Access Bazaar
- Built company marketing site - accessbazaar.com
- Designed all company print work - banners, flyers, emails, business cards, etc.
- Designed and developed e-commerce checkout pages and flow
- Developed front-end cart module to power e-commerce app
- Made improvements to internal admin/CMS platform - product listings, category management, etc.
- Built multiple API endpoints using Django rest framework
- Wrote several gulp tasks to handle preprocessing and other tasks
Software Development Intern - Angular, Python, Django, Postgres, LESS, Heroku
Feb 2016 - Jun 2016
Access Bazaar
- Wrote api endpoints to read and write product reviews on ecommerce site
- Developed several UI components for MVP application
- Video/image editing and asset creation
- Wrote styling libraries in less/sass to establish current look of product
Dance Studio Manager
2010 - Present
Studio E School of Dance
- Built and currently maintain public website studioe.net
- Oversee and manage all studio operations
- Manage a team of 3 receptionists and supervise their activity
- Plan studio functions (recitals, events, socials, large performances)
- Create class scheduling and plan curriculums
- Lead customer support and manage customer relations
- Maintain database of studio operations and customer data