PolyhedronGeometryVertex class
PolyhedronGeometryVertex is a Vector3 decorator to allow introducing index and uv.
class PolyhedronGeometryVertex extends Vector3 {
int index;
UV uv;
PolyhedronGeometryVertex([num x = 0.0, num y = 0.0, num z = 0.0]) : super(x.toDouble(), y.toDouble(), z.toDouble());
PolyhedronGeometryVertex.fromVector3(Vector3 other) : super.copy(other);
}
Extends
Vector3 > PolyhedronGeometryVertex
Constructors
Properties
double b #
inherited from Vector3
double get b => storage[2];
set b(double arg) => storage[2] = arg;
final Vector3 bbb #
inherited from Vector3
Vector3 get bbb => new Vector3(storage[2], storage[2], storage[2]);
final Vector4 bbbb #
inherited from Vector3
Vector4 get bbbb => new Vector4(storage[2], storage[2], storage[2], storage[2]);
final Vector4 bbbg #
inherited from Vector3
Vector4 get bbbg => new Vector4(storage[2], storage[2], storage[2], storage[1]);
final Vector4 bbbr #
inherited from Vector3
Vector4 get bbbr => new Vector4(storage[2], storage[2], storage[2], storage[0]);
final Vector3 bbg #
inherited from Vector3
Vector3 get bbg => new Vector3(storage[2], storage[2], storage[1]);
final Vector4 bbgb #
inherited from Vector3
Vector4 get bbgb => new Vector4(storage[2], storage[2], storage[1], storage[2]);
final Vector4 bbgg #
inherited from Vector3
Vector4 get bbgg => new Vector4(storage[2], storage[2], storage[1], storage[1]);
final Vector4 bbgr #
inherited from Vector3
Vector4 get bbgr => new Vector4(storage[2], storage[2], storage[1], storage[0]);
final Vector3 bbr #
inherited from Vector3
Vector3 get bbr => new Vector3(storage[2], storage[2], storage[0]);
final Vector4 bbrb #
inherited from Vector3
Vector4 get bbrb => new Vector4(storage[2], storage[2], storage[0], storage[2]);
final Vector4 bbrg #
inherited from Vector3
Vector4 get bbrg => new Vector4(storage[2], storage[2], storage[0], storage[1]);
final Vector4 bbrr #
inherited from Vector3
Vector4 get bbrr => new Vector4(storage[2], storage[2], storage[0], storage[0]);
Vector2 bg #
inherited from Vector3
Vector2 get bg => new Vector2(storage[2], storage[1]);
set bg(Vector2 arg) {
storage[2] = arg.storage[0];
storage[1] = arg.storage[1];
}
final Vector3 bgb #
inherited from Vector3
Vector3 get bgb => new Vector3(storage[2], storage[1], storage[2]);
final Vector4 bgbb #
inherited from Vector3
Vector4 get bgbb => new Vector4(storage[2], storage[1], storage[2], storage[2]);
final Vector4 bgbg #
inherited from Vector3
Vector4 get bgbg => new Vector4(storage[2], storage[1], storage[2], storage[1]);
final Vector4 bgbr #
inherited from Vector3
Vector4 get bgbr => new Vector4(storage[2], storage[1], storage[2], storage[0]);
final Vector3 bgg #
inherited from Vector3
Vector3 get bgg => new Vector3(storage[2], storage[1], storage[1]);
final Vector4 bggb #
inherited from Vector3
Vector4 get bggb => new Vector4(storage[2], storage[1], storage[1], storage[2]);
final Vector4 bggg #
inherited from Vector3
Vector4 get bggg => new Vector4(storage[2], storage[1], storage[1], storage[1]);
final Vector4 bggr #
inherited from Vector3
Vector4 get bggr => new Vector4(storage[2], storage[1], storage[1], storage[0]);
Vector3 bgr #
inherited from Vector3
Vector3 get bgr => new Vector3(storage[2], storage[1], storage[0]);
set bgr(Vector3 arg) {
storage[2] = arg.storage[0];
storage[1] = arg.storage[1];
storage[0] = arg.storage[2];
}
final Vector4 bgrb #
inherited from Vector3
Vector4 get bgrb => new Vector4(storage[2], storage[1], storage[0], storage[2]);
final Vector4 bgrg #
inherited from Vector3
Vector4 get bgrg => new Vector4(storage[2], storage[1], storage[0], storage[1]);
final Vector4 bgrr #
inherited from Vector3
Vector4 get bgrr => new Vector4(storage[2], storage[1], storage[0], storage[0]);
Vector2 br #
inherited from Vector3
Vector2 get br => new Vector2(storage[2], storage[0]);
set br(Vector2 arg) {
storage[2] = arg.storage[0];
storage[0] = arg.storage[1];
}
final Vector3 brb #
inherited from Vector3
Vector3 get brb => new Vector3(storage[2], storage[0], storage[2]);
final Vector4 brbb #
inherited from Vector3
Vector4 get brbb => new Vector4(storage[2], storage[0], storage[2], storage[2]);
final Vector4 brbg #
inherited from Vector3
Vector4 get brbg => new Vector4(storage[2], storage[0], storage[2], storage[1]);
final Vector4 brbr #
inherited from Vector3
Vector4 get brbr => new Vector4(storage[2], storage[0], storage[2], storage[0]);
Vector3 brg #
inherited from Vector3
Vector3 get brg => new Vector3(storage[2], storage[0], storage[1]);
set brg(Vector3 arg) {
storage[2] = arg.storage[0];
storage[0] = arg.storage[1];
storage[1] = arg.storage[2];
}
final Vector4 brgb #
inherited from Vector3
Vector4 get brgb => new Vector4(storage[2], storage[0], storage[1], storage[2]);
final Vector4 brgg #
inherited from Vector3
Vector4 get brgg => new Vector4(storage[2], storage[0], storage[1], storage[1]);
final Vector4 brgr #
inherited from Vector3
Vector4 get brgr => new Vector4(storage[2], storage[0], storage[1], storage[0]);
final Vector3 brr #
inherited from Vector3
Vector3 get brr => new Vector3(storage[2], storage[0], storage[0]);
final Vector4 brrb #
inherited from Vector3
Vector4 get brrb => new Vector4(storage[2], storage[0], storage[0], storage[2]);
final Vector4 brrg #
inherited from Vector3
Vector4 get brrg => new Vector4(storage[2], storage[0], storage[0], storage[1]);
final Vector4 brrr #
inherited from Vector3
Vector4 get brrr => new Vector4(storage[2], storage[0], storage[0], storage[0]);
double g #
inherited from Vector3
double get g => storage[1];
set g(double arg) => storage[1] = arg;
Vector2 gb #
inherited from Vector3
Vector2 get gb => new Vector2(storage[1], storage[2]);
set gb(Vector2 arg) {
storage[1] = arg.storage[0];
storage[2] = arg.storage[1];
}
final Vector3 gbb #
inherited from Vector3
Vector3 get gbb => new Vector3(storage[1], storage[2], storage[2]);
final Vector4 gbbb #
inherited from Vector3
Vector4 get gbbb => new Vector4(storage[1], storage[2], storage[2], storage[2]);
final Vector4 gbbg #
inherited from Vector3
Vector4 get gbbg => new Vector4(storage[1], storage[2], storage[2], storage[1]);
final Vector4 gbbr #
inherited from Vector3
Vector4 get gbbr => new Vector4(storage[1], storage[2], storage[2], storage[0]);
final Vector3 gbg #
inherited from Vector3
Vector3 get gbg => new Vector3(storage[1], storage[2], storage[1]);
final Vector4 gbgb #
inherited from Vector3
Vector4 get gbgb => new Vector4(storage[1], storage[2], storage[1], storage[2]);
final Vector4 gbgg #
inherited from Vector3
Vector4 get gbgg => new Vector4(storage[1], storage[2], storage[1], storage[1]);
final Vector4 gbgr #
inherited from Vector3
Vector4 get gbgr => new Vector4(storage[1], storage[2], storage[1], storage[0]);
Vector3 gbr #
inherited from Vector3
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];
}
final Vector4 gbrb #
inherited from Vector3
Vector4 get gbrb => new Vector4(storage[1], storage[2], storage[0], storage[2]);
final Vector4 gbrg #
inherited from Vector3
Vector4 get gbrg => new Vector4(storage[1], storage[2], storage[0], storage[1]);
final Vector4 gbrr #
inherited from Vector3
Vector4 get gbrr => new Vector4(storage[1], storage[2], storage[0], storage[0]);
final Vector3 ggb #
inherited from Vector3
Vector3 get ggb => new Vector3(storage[1], storage[1], storage[2]);
final Vector4 ggbb #
inherited from Vector3
Vector4 get ggbb => new Vector4(storage[1], storage[1], storage[2], storage[2]);
final Vector4 ggbg #
inherited from Vector3
Vector4 get ggbg => new Vector4(storage[1], storage[1], storage[2], storage[1]);
final Vector4 ggbr #
inherited from Vector3
Vector4 get ggbr => new Vector4(storage[1], storage[1], storage[2], storage[0]);
final Vector3 ggg #
inherited from Vector3
Vector3 get ggg => new Vector3(storage[1], storage[1], storage[1]);
final Vector4 gggb #
inherited from Vector3
Vector4 get gggb => new Vector4(storage[1], storage[1], storage[1], storage[2]);
final Vector4 gggg #
inherited from Vector3
Vector4 get gggg => new Vector4(storage[1], storage[1], storage[1], storage[1]);
final Vector4 gggr #
inherited from Vector3
Vector4 get gggr => new Vector4(storage[1], storage[1], storage[1], storage[0]);
final Vector3 ggr #
inherited from Vector3
Vector3 get ggr => new Vector3(storage[1], storage[1], storage[0]);
final Vector4 ggrb #
inherited from Vector3
Vector4 get ggrb => new Vector4(storage[1], storage[1], storage[0], storage[2]);
final Vector4 ggrg #
inherited from Vector3
Vector4 get ggrg => new Vector4(storage[1], storage[1], storage[0], storage[1]);
final Vector4 ggrr #
inherited from Vector3
Vector4 get ggrr => new Vector4(storage[1], storage[1], storage[0], storage[0]);
Vector2 gr #
inherited from Vector3
Vector2 get gr => new Vector2(storage[1], storage[0]);
set gr(Vector2 arg) {
storage[1] = arg.storage[0];
storage[0] = arg.storage[1];
}
Vector3 grb #
inherited from Vector3
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];
}
final Vector4 grbb #
inherited from Vector3
Vector4 get grbb => new Vector4(storage[1], storage[0], storage[2], storage[2]);
final Vector4 grbg #
inherited from Vector3
Vector4 get grbg => new Vector4(storage[1], storage[0], storage[2], storage[1]);
final Vector4 grbr #
inherited from Vector3
Vector4 get grbr => new Vector4(storage[1], storage[0], storage[2], storage[0]);
final Vector3 grg #
inherited from Vector3
Vector3 get grg => new Vector3(storage[1], storage[0], storage[1]);
final Vector4 grgb #
inherited from Vector3
Vector4 get grgb => new Vector4(storage[1], storage[0], storage[1], storage[2]);
final Vector4 grgg #
inherited from Vector3
Vector4 get grgg => new Vector4(storage[1], storage[0], storage[1], storage[1]);
final Vector4 grgr #
inherited from Vector3
Vector4 get grgr => new Vector4(storage[1], storage[0], storage[1], storage[0]);
final Vector3 grr #
inherited from Vector3
Vector3 get grr => new Vector3(storage[1], storage[0], storage[0]);
final Vector4 grrb #
inherited from Vector3
Vector4 get grrb => new Vector4(storage[1], storage[0], storage[0], storage[2]);
final Vector4 grrg #
inherited from Vector3
Vector4 get grrg => new Vector4(storage[1], storage[0], storage[0], storage[1]);
final Vector4 grrr #
inherited from Vector3
Vector4 get grrr => new Vector4(storage[1], storage[0], storage[0], storage[0]);
final bool isInfinite #
inherited from Vector3
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;
return is_infinite;
}
final bool isNaN #
inherited from Vector3
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;
return is_nan;
}
final double length #
inherited from Vector3
Length.
double get length {
double sum;
sum = (storage[0] * storage[0]);
sum += (storage[1] * storage[1]);
sum += (storage[2] * storage[2]);
return Math.sqrt(sum);
}
final double length2 #
inherited from Vector3
Length squared.
double get length2 {
double sum;
sum = (storage[0] * storage[0]);
sum += (storage[1] * storage[1]);
sum += (storage[2] * storage[2]);
return sum;
}
double p #
inherited from Vector3
double get p => storage[2];
set p(double arg) => storage[2] = arg;
final Vector3 ppp #
inherited from Vector3
Vector3 get ppp => new Vector3(storage[2], storage[2], storage[2]);
final Vector4 pppp #
inherited from Vector3
Vector4 get pppp => new Vector4(storage[2], storage[2], storage[2], storage[2]);
final Vector4 ppps #
inherited from Vector3
Vector4 get ppps => new Vector4(storage[2], storage[2], storage[2], storage[0]);
final Vector4 pppt #
inherited from Vector3
Vector4 get pppt => new Vector4(storage[2], storage[2], storage[2], storage[1]);
final Vector3 pps #
inherited from Vector3
Vector3 get pps => new Vector3(storage[2], storage[2], storage[0]);
final Vector4 ppsp #
inherited from Vector3
Vector4 get ppsp => new Vector4(storage[2], storage[2], storage[0], storage[2]);
final Vector4 ppss #
inherited from Vector3
Vector4 get ppss => new Vector4(storage[2], storage[2], storage[0], storage[0]);
final Vector4 ppst #
inherited from Vector3
Vector4 get ppst => new Vector4(storage[2], storage[2], storage[0], storage[1]);
final Vector3 ppt #
inherited from Vector3
Vector3 get ppt => new Vector3(storage[2], storage[2], storage[1]);
final Vector4 pptp #
inherited from Vector3
Vector4 get pptp => new Vector4(storage[2], storage[2], storage[1], storage[2]);
final Vector4 ppts #
inherited from Vector3
Vector4 get ppts => new Vector4(storage[2], storage[2], storage[1], storage[0]);
final Vector4 pptt #
inherited from Vector3
Vector4 get pptt => new Vector4(storage[2], storage[2], storage[1], storage[1]);
Vector2 ps #
inherited from Vector3
Vector2 get ps => new Vector2(storage[2], storage[0]);
set ps(Vector2 arg) {
storage[2] = arg.storage[0];
storage[0] = arg.storage[1];
}
final Vector3 psp #
inherited from Vector3
Vector3 get psp => new Vector3(storage[2], storage[0], storage[2]);
final Vector4 pspp #
inherited from Vector3
Vector4 get pspp => new Vector4(storage[2], storage[0], storage[2], storage[2]);
final Vector4 psps #
inherited from Vector3
Vector4 get psps => new Vector4(storage[2], storage[0], storage[2], storage[0]);
final Vector4 pspt #
inherited from Vector3
Vector4 get pspt => new Vector4(storage[2], storage[0], storage[2], storage[1]);
final Vector3 pss #
inherited from Vector3
Vector3 get pss => new Vector3(storage[2], storage[0], storage[0]);
final Vector4 pssp #
inherited from Vector3
Vector4 get pssp => new Vector4(storage[2], storage[0], storage[0], storage[2]);
final Vector4 psss #
inherited from Vector3
Vector4 get psss => new Vector4(storage[2], storage[0], storage[0], storage[0]);
final Vector4 psst #
inherited from Vector3
Vector4 get psst => new Vector4(storage[2], storage[0], storage[0], storage[1]);
Vector3 pst #
inherited from Vector3
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 #
inherited from Vector3
Vector4 get pstp => new Vector4(storage[2], storage[0], storage[1], storage[2]);
final Vector4 psts #
inherited from Vector3
Vector4 get psts => new Vector4(storage[2], storage[0], storage[1], storage[0]);
final Vector4 pstt #
inherited from Vector3
Vector4 get pstt => new Vector4(storage[2], storage[0], storage[1], storage[1]);
Vector2 pt #
inherited from Vector3
Vector2 get pt => new Vector2(storage[2], storage[1]);
set pt(Vector2 arg) {
storage[2] = arg.storage[0];
storage[1] = arg.storage[1];
}
final Vector3 ptp #
inherited from Vector3
Vector3 get ptp => new Vector3(storage[2], storage[1], storage[2]);
final Vector4 ptpp #
inherited from Vector3
Vector4 get ptpp => new Vector4(storage[2], storage[1], storage[2], storage[2]);
final Vector4 ptps #
inherited from Vector3
Vector4 get ptps => new Vector4(storage[2], storage[1], storage[2], storage[0]);
final Vector4 ptpt #
inherited from Vector3
Vector4 get ptpt => new Vector4(storage[2], storage[1], storage[2], storage[1]);
Vector3 pts #
inherited from Vector3
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 #
inherited from Vector3
Vector4 get ptsp => new Vector4(storage[2], storage[1], storage[0], storage[2]);
final Vector4 ptss #
inherited from Vector3
Vector4 get ptss => new Vector4(storage[2], storage[1], storage[0], storage[0]);
final Vector4 ptst #
inherited from Vector3
Vector4 get ptst => new Vector4(storage[2], storage[1], storage[0], storage[1]);
final Vector3 ptt #
inherited from Vector3
Vector3 get ptt => new Vector3(storage[2], storage[1], storage[1]);
final Vector4 pttp #
inherited from Vector3
Vector4 get pttp => new Vector4(storage[2], storage[1], storage[1], storage[2]);
final Vector4 ptts #
inherited from Vector3
Vector4 get ptts => new Vector4(storage[2], storage[1], storage[1], storage[0]);
final Vector4 pttt #
inherited from Vector3
Vector4 get pttt => new Vector4(storage[2], storage[1], storage[1], storage[1]);
double r #
inherited from Vector3
double get r => storage[0];
set r(double arg) => storage[0] = arg;
Vector2 rb #
inherited from Vector3
Vector2 get rb => new Vector2(storage[0], storage[2]);
set rb(Vector2 arg) {
storage[0] = arg.storage[0];
storage[2] = arg.storage[1];
}
final Vector3 rbb #
inherited from Vector3
Vector3 get rbb => new Vector3(storage[0], storage[2], storage[2]);
final Vector4 rbbb #
inherited from Vector3
Vector4 get rbbb => new Vector4(storage[0], storage[2], storage[2], storage[2]);
final Vector4 rbbg #
inherited from Vector3
Vector4 get rbbg => new Vector4(storage[0], storage[2], storage[2], storage[1]);
final Vector4 rbbr #
inherited from Vector3
Vector4 get rbbr => new Vector4(storage[0], storage[2], storage[2], storage[0]);
Vector3 rbg #
inherited from Vector3
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];
}
final Vector4 rbgb #
inherited from Vector3
Vector4 get rbgb => new Vector4(storage[0], storage[2], storage[1], storage[2]);
final Vector4 rbgg #
inherited from Vector3
Vector4 get rbgg => new Vector4(storage[0], storage[2], storage[1], storage[1]);
final Vector4 rbgr #
inherited from Vector3
Vector4 get rbgr => new Vector4(storage[0], storage[2], storage[1], storage[0]);
final Vector3 rbr #
inherited from Vector3
Vector3 get rbr => new Vector3(storage[0], storage[2], storage[0]);
final Vector4 rbrb #
inherited from Vector3
Vector4 get rbrb => new Vector4(storage[0], storage[2], storage[0], storage[2]);
final Vector4 rbrg #
inherited from Vector3
Vector4 get rbrg => new Vector4(storage[0], storage[2], storage[0], storage[1]);
final Vector4 rbrr #
inherited from Vector3
Vector4 get rbrr => new Vector4(storage[0], storage[2], storage[0], storage[0]);
Vector2 rg #
inherited from Vector3
Vector2 get rg => new Vector2(storage[0], storage[1]);
set rg(Vector2 arg) {
storage[0] = arg.storage[0];
storage[1] = arg.storage[1];
}
Vector3 rgb #
inherited from Vector3
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];
}
final Vector4 rgbb #
inherited from Vector3
Vector4 get rgbb => new Vector4(storage[0], storage[1], storage[2], storage[2]);
final Vector4 rgbg #
inherited from Vector3
Vector4 get rgbg => new Vector4(storage[0], storage[1], storage[2], storage[1]);
final Vector4 rgbr #
inherited from Vector3
Vector4 get rgbr => new Vector4(storage[0], storage[1], storage[2], storage[0]);
final Vector3 rgg #
inherited from Vector3
Vector3 get rgg => new Vector3(storage[0], storage[1], storage[1]);
final Vector4 rggb #
inherited from Vector3
Vector4 get rggb => new Vector4(storage[0], storage[1], storage[1], storage[2]);
final Vector4 rggg #
inherited from Vector3
Vector4 get rggg => new Vector4(storage[0], storage[1], storage[1], storage[1]);
final Vector4 rggr #
inherited from Vector3
Vector4 get rggr => new Vector4(storage[0], storage[1], storage[1], storage[0]);
final Vector3 rgr #
inherited from Vector3
Vector3 get rgr => new Vector3(storage[0], storage[1], storage[0]);
final Vector4 rgrb #
inherited from Vector3
Vector4 get rgrb => new Vector4(storage[0], storage[1], storage[0], storage[2]);
final Vector4 rgrg #
inherited from Vector3
Vector4 get rgrg => new Vector4(storage[0], storage[1], storage[0], storage[1]);
final Vector4 rgrr #
inherited from Vector3
Vector4 get rgrr => new Vector4(storage[0], storage[1], storage[0], storage[0]);
final Vector3 rrb #
inherited from Vector3
Vector3 get rrb => new Vector3(storage[0], storage[0], storage[2]);
final Vector4 rrbb #
inherited from Vector3
Vector4 get rrbb => new Vector4(storage[0], storage[0], storage[2], storage[2]);
final Vector4 rrbg #
inherited from Vector3
Vector4 get rrbg => new Vector4(storage[0], storage[0], storage[2], storage[1]);
final Vector4 rrbr #
inherited from Vector3
Vector4 get rrbr => new Vector4(storage[0], storage[0], storage[2], storage[0]);
final Vector3 rrg #
inherited from Vector3
Vector3 get rrg => new Vector3(storage[0], storage[0], storage[1]);
final Vector4 rrgb #
inherited from Vector3
Vector4 get rrgb => new Vector4(storage[0], storage[0], storage[1], storage[2]);
final Vector4 rrgg #
inherited from Vector3
Vector4 get rrgg => new Vector4(storage[0], storage[0], storage[1], storage[1]);
final Vector4 rrgr #
inherited from Vector3
Vector4 get rrgr => new Vector4(storage[0], storage[0], storage[1], storage[0]);
final Vector3 rrr #
inherited from Vector3
Vector3 get rrr => new Vector3(storage[0], storage[0], storage[0]);
final Vector4 rrrb #
inherited from Vector3
Vector4 get rrrb => new Vector4(storage[0], storage[0], storage[0], storage[2]);
final Vector4 rrrg #
inherited from Vector3
Vector4 get rrrg => new Vector4(storage[0], storage[0], storage[0], storage[1]);
final Vector4 rrrr #
inherited from Vector3
Vector4 get rrrr => new Vector4(storage[0], storage[0], storage[0], storage[0]);
double s #
inherited from Vector3
double get s => storage[0];
set s(double arg) => storage[0] = arg;
Vector2 sp #
inherited from Vector3
Vector2 get sp => new Vector2(storage[0], storage[2]);
set sp(Vector2 arg) {
storage[0] = arg.storage[0];
storage[2] = arg.storage[1];
}
final Vector3 spp #
inherited from Vector3
Vector3 get spp => new Vector3(storage[0], storage[2], storage[2]);
final Vector4 sppp #
inherited from Vector3
Vector4 get sppp => new Vector4(storage[0], storage[2], storage[2], storage[2]);
final Vector4 spps #
inherited from Vector3
Vector4 get spps => new Vector4(storage[0], storage[2], storage[2], storage[0]);
final Vector4 sppt #
inherited from Vector3
Vector4 get sppt => new Vector4(storage[0], storage[2], storage[2], storage[1]);
final Vector3 sps #
inherited from Vector3
Vector3 get sps => new Vector3(storage[0], storage[2], storage[0]);
final Vector4 spsp #
inherited from Vector3
Vector4 get spsp => new Vector4(storage[0], storage[2], storage[0], storage[2]);
final Vector4 spss #
inherited from Vector3
Vector4 get spss => new Vector4(storage[0], storage[2], storage[0], storage[0]);
final Vector4 spst #
inherited from Vector3
Vector4 get spst => new Vector4(storage[0], storage[2], storage[0], storage[1]);
Vector3 spt #
inherited from Vector3
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 #
inherited from Vector3
Vector4 get sptp => new Vector4(storage[0], storage[2], storage[1], storage[2]);
final Vector4 spts #
inherited from Vector3
Vector4 get spts => new Vector4(storage[0], storage[2], storage[1], storage[0]);
final Vector4 sptt #
inherited from Vector3
Vector4 get sptt => new Vector4(storage[0], storage[2], storage[1], storage[1]);
final Vector3 ssp #
inherited from Vector3
Vector3 get ssp => new Vector3(storage[0], storage[0], storage[2]);
final Vector4 sspp #
inherited from Vector3
Vector4 get sspp => new Vector4(storage[0], storage[0], storage[2], storage[2]);
final Vector4 ssps #
inherited from Vector3
Vector4 get ssps => new Vector4(storage[0], storage[0], storage[2], storage[0]);
final Vector4 sspt #
inherited from Vector3
Vector4 get sspt => new Vector4(storage[0], storage[0], storage[2], storage[1]);
final Vector3 sss #
inherited from Vector3
Vector3 get sss => new Vector3(storage[0], storage[0], storage[0]);
final Vector4 sssp #
inherited from Vector3
Vector4 get sssp => new Vector4(storage[0], storage[0], storage[0], storage[2]);
final Vector4 ssss #
inherited from Vector3
Vector4 get ssss => new Vector4(storage[0], storage[0], storage[0], storage[0]);
final Vector4 ssst #
inherited from Vector3
Vector4 get ssst => new Vector4(storage[0], storage[0], storage[0], storage[1]);
final Vector3 sst #
inherited from Vector3
Vector3 get sst => new Vector3(storage[0], storage[0], storage[1]);
final Vector4 sstp #
inherited from Vector3
Vector4 get sstp => new Vector4(storage[0], storage[0], storage[1], storage[2]);
final Vector4 ssts #
inherited from Vector3
Vector4 get ssts => new Vector4(storage[0], storage[0], storage[1], storage[0]);
final Vector4 sstt #
inherited from Vector3
Vector4 get sstt => new Vector4(storage[0], storage[0], storage[1], storage[1]);
Vector2 st #
inherited from Vector3
Vector2 get st => new Vector2(storage[0], storage[1]);
set st(Vector2 arg) {
storage[0] = arg.storage[0];
storage[1] = arg.storage[1];
}
Vector3 stp #
inherited from Vector3
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 #
inherited from Vector3
Vector4 get stpp => new Vector4(storage[0], storage[1], storage[2], storage[2]);
final Vector4 stps #
inherited from Vector3
Vector4 get stps => new Vector4(storage[0], storage[1], storage[2], storage[0]);
final Vector4 stpt #
inherited from Vector3
Vector4 get stpt => new Vector4(storage[0], storage[1], storage[2], storage[1]);
final Vector3 sts #
inherited from Vector3
Vector3 get sts => new Vector3(storage[0], storage[1], storage[0]);
final Vector4 stsp #
inherited from Vector3
Vector4 get stsp => new Vector4(storage[0], storage[1], storage[0], storage[2]);
final Vector4 stss #
inherited from Vector3
Vector4 get stss => new Vector4(storage[0], storage[1], storage[0], storage[0]);
final Vector4 stst #
inherited from Vector3
Vector4 get stst => new Vector4(storage[0], storage[1], storage[0], storage[1]);
final Vector3 stt #
inherited from Vector3
Vector3 get stt => new Vector3(storage[0], storage[1], storage[1]);
final Vector4 sttp #
inherited from Vector3
Vector4 get sttp => new Vector4(storage[0], storage[1], storage[1], storage[2]);
final Vector4 stts #
inherited from Vector3
Vector4 get stts => new Vector4(storage[0], storage[1], storage[1], storage[0]);
final Vector4 sttt #
inherited from Vector3
Vector4 get sttt => new Vector4(storage[0], storage[1], storage[1], storage[1]);
double t #
inherited from Vector3
double get t => storage[1];
set t(double arg) => storage[1] = arg;
Vector2 tp #
inherited from Vector3
Vector2 get tp => new Vector2(storage[1], storage[2]);
set tp(Vector2 arg) {
storage[1] = arg.storage[0];
storage[2] = arg.storage[1];
}
final Vector3 tpp #
inherited from Vector3
Vector3 get tpp => new Vector3(storage[1], storage[2], storage[2]);
final Vector4 tppp #
inherited from Vector3
Vector4 get tppp => new Vector4(storage[1], storage[2], storage[2], storage[2]);
final Vector4 tpps #
inherited from Vector3
Vector4 get tpps => new Vector4(storage[1], storage[2], storage[2], storage[0]);
final Vector4 tppt #
inherited from Vector3
Vector4 get tppt => new Vector4(storage[1], storage[2], storage[2], storage[1]);
Vector3 tps #
inherited from Vector3
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 #
inherited from Vector3
Vector4 get tpsp => new Vector4(storage[1], storage[2], storage[0], storage[2]);
final Vector4 tpss #
inherited from Vector3
Vector4 get tpss => new Vector4(storage[1], storage[2], storage[0], storage[0]);
final Vector4 tpst #
inherited from Vector3
Vector4 get tpst => new Vector4(storage[1], storage[2], storage[0], storage[1]);
final Vector3 tpt #
inherited from Vector3
Vector3 get tpt => new Vector3(storage[1], storage[2], storage[1]);
final Vector4 tptp #
inherited from Vector3
Vector4 get tptp => new Vector4(storage[1], storage[2], storage[1], storage[2]);
final Vector4 tpts #
inherited from Vector3
Vector4 get tpts => new Vector4(storage[1], storage[2], storage[1], storage[0]);
final Vector4 tptt #
inherited from Vector3
Vector4 get tptt => new Vector4(storage[1], storage[2], storage[1], storage[1]);
Vector2 ts #
inherited from Vector3
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 #
inherited from Vector3
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 #
inherited from Vector3
Vector4 get tspp => new Vector4(storage[1], storage[0], storage[2], storage[2]);
final Vector4 tsps #
inherited from Vector3
Vector4 get tsps => new Vector4(storage[1], storage[0], storage[2], storage[0]);
final Vector4 tspt #
inherited from Vector3
Vector4 get tspt => new Vector4(storage[1], storage[0], storage[2], storage[1]);
final Vector3 tss #
inherited from Vector3
Vector3 get tss => new Vector3(storage[1], storage[0], storage[0]);
final Vector4 tssp #
inherited from Vector3
Vector4 get tssp => new Vector4(storage[1], storage[0], storage[0], storage[2]);
final Vector4 tsss #
inherited from Vector3
Vector4 get tsss => new Vector4(storage[1], storage[0], storage[0], storage[0]);
final Vector4 tsst #
inherited from Vector3
Vector4 get tsst => new Vector4(storage[1], storage[0], storage[0], storage[1]);
final Vector3 tst #
inherited from Vector3
Vector3 get tst => new Vector3(storage[1], storage[0], storage[1]);
final Vector4 tstp #
inherited from Vector3
Vector4 get tstp => new Vector4(storage[1], storage[0], storage[1], storage[2]);
final Vector4 tsts #
inherited from Vector3
Vector4 get tsts => new Vector4(storage[1], storage[0], storage[1], storage[0]);
final Vector4 tstt #
inherited from Vector3
Vector4 get tstt => new Vector4(storage[1], storage[0], storage[1], storage[1]);
final Vector3 ttp #
inherited from Vector3
Vector3 get ttp => new Vector3(storage[1], storage[1], storage[2]);
final Vector4 ttpp #
inherited from Vector3
Vector4 get ttpp => new Vector4(storage[1], storage[1], storage[2], storage[2]);
final Vector4 ttps #
inherited from Vector3
Vector4 get ttps => new Vector4(storage[1], storage[1], storage[2], storage[0]);
final Vector4 ttpt #
inherited from Vector3
Vector4 get ttpt => new Vector4(storage[1], storage[1], storage[2], storage[1]);
final Vector3 tts #
inherited from Vector3
Vector3 get tts => new Vector3(storage[1], storage[1], storage[0]);
final Vector4 ttsp #
inherited from Vector3
Vector4 get ttsp => new Vector4(storage[1], storage[1], storage[0], storage[2]);
final Vector4 ttss #
inherited from Vector3
Vector4 get ttss => new Vector4(storage[1], storage[1], storage[0], storage[0]);
final Vector4 ttst #
inherited from Vector3
Vector4 get ttst => new Vector4(storage[1], storage[1], storage[0], storage[1]);
final Vector3 ttt #
inherited from Vector3
Vector3 get ttt => new Vector3(storage[1], storage[1], storage[1]);
final Vector4 tttp #
inherited from Vector3
Vector4 get tttp => new Vector4(storage[1], storage[1], storage[1], storage[2]);
final Vector4 ttts #
inherited from Vector3
Vector4 get ttts => new Vector4(storage[1], storage[1], storage[1], storage[0]);
final Vector4 tttt #
inherited from Vector3
Vector4 get tttt => new Vector4(storage[1], storage[1], storage[1], storage[1]);
double x #
inherited from Vector3
double get x => storage[0];
set x(double arg) => storage[0] = arg;
final Vector3 xxx #
inherited from Vector3
Vector3 get xxx => new Vector3(storage[0], storage[0], storage[0]);
final Vector4 xxxx #
inherited from Vector3
Vector4 get xxxx => new Vector4(storage[0], storage[0], storage[0], storage[0]);
final Vector4 xxxy #
inherited from Vector3
Vector4 get xxxy => new Vector4(storage[0], storage[0], storage[0], storage[1]);
final Vector4 xxxz #
inherited from Vector3
Vector4 get xxxz => new Vector4(storage[0], storage[0], storage[0], storage[2]);
final Vector3 xxy #
inherited from Vector3
Vector3 get xxy => new Vector3(storage[0], storage[0], storage[1]);
final Vector4 xxyx #
inherited from Vector3
Vector4 get xxyx => new Vector4(storage[0], storage[0], storage[1], storage[0]);
final Vector4 xxyy #
inherited from Vector3
Vector4 get xxyy => new Vector4(storage[0], storage[0], storage[1], storage[1]);
final Vector4 xxyz #
inherited from Vector3
Vector4 get xxyz => new Vector4(storage[0], storage[0], storage[1], storage[2]);
final Vector3 xxz #
inherited from Vector3
Vector3 get xxz => new Vector3(storage[0], storage[0], storage[2]);
final Vector4 xxzx #
inherited from Vector3
Vector4 get xxzx => new Vector4(storage[0], storage[0], storage[2], storage[0]);
final Vector4 xxzy #
inherited from Vector3
Vector4 get xxzy => new Vector4(storage[0], storage[0], storage[2], storage[1]);
final Vector4 xxzz #
inherited from Vector3
Vector4 get xxzz => new Vector4(storage[0], storage[0], storage[2], storage[2]);
Vector2 xy #
inherited from Vector3
Vector2 get xy => new Vector2(storage[0], storage[1]);
set xy(Vector2 arg) {
storage[0] = arg.storage[0];
storage[1] = arg.storage[1];
}
final Vector3 xyx #
inherited from Vector3
Vector3 get xyx => new Vector3(storage[0], storage[1], storage[0]);
final Vector4 xyxx #
inherited from Vector3
Vector4 get xyxx => new Vector4(storage[0], storage[1], storage[0], storage[0]);
final Vector4 xyxy #
inherited from Vector3
Vector4 get xyxy => new Vector4(storage[0], storage[1], storage[0], storage[1]);
final Vector4 xyxz #
inherited from Vector3
Vector4 get xyxz => new Vector4(storage[0], storage[1], storage[0], storage[2]);
final Vector3 xyy #
inherited from Vector3
Vector3 get xyy => new Vector3(storage[0], storage[1], storage[1]);
final Vector4 xyyx #
inherited from Vector3
Vector4 get xyyx => new Vector4(storage[0], storage[1], storage[1], storage[0]);
final Vector4 xyyy #
inherited from Vector3
Vector4 get xyyy => new Vector4(storage[0], storage[1], storage[1], storage[1]);
final Vector4 xyyz #
inherited from Vector3
Vector4 get xyyz => new Vector4(storage[0], storage[1], storage[1], storage[2]);
Vector3 xyz #
inherited from Vector3
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];
}
final Vector4 xyzx #
inherited from Vector3
Vector4 get xyzx => new Vector4(storage[0], storage[1], storage[2], storage[0]);
final Vector4 xyzy #
inherited from Vector3
Vector4 get xyzy => new Vector4(storage[0], storage[1], storage[2], storage[1]);
final Vector4 xyzz #
inherited from Vector3
Vector4 get xyzz => new Vector4(storage[0], storage[1], storage[2], storage[2]);
Vector2 xz #
inherited from Vector3
Vector2 get xz => new Vector2(storage[0], storage[2]);
set xz(Vector2 arg) {
storage[0] = arg.storage[0];
storage[2] = arg.storage[1];
}
final Vector3 xzx #
inherited from Vector3
Vector3 get xzx => new Vector3(storage[0], storage[2], storage[0]);
final Vector4 xzxx #
inherited from Vector3
Vector4 get xzxx => new Vector4(storage[0], storage[2], storage[0], storage[0]);
final Vector4 xzxy #
inherited from Vector3
Vector4 get xzxy => new Vector4(storage[0], storage[2], storage[0], storage[1]);
final Vector4 xzxz #
inherited from Vector3
Vector4 get xzxz => new Vector4(storage[0], storage[2], storage[0], storage[2]);
Vector3 xzy #
inherited from Vector3
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];
}
final Vector4 xzyx #
inherited from Vector3
Vector4 get xzyx => new Vector4(storage[0], storage[2], storage[1], storage[0]);
final Vector4 xzyy #
inherited from Vector3
Vector4 get xzyy => new Vector4(storage[0], storage[2], storage[1], storage[1]);
final Vector4 xzyz #
inherited from Vector3
Vector4 get xzyz => new Vector4(storage[0], storage[2], storage[1], storage[2]);
final Vector3 xzz #
inherited from Vector3
Vector3 get xzz => new Vector3(storage[0], storage[2], storage[2]);
final Vector4 xzzx #
inherited from Vector3
Vector4 get xzzx => new Vector4(storage[0], storage[2], storage[2], storage[0]);
final Vector4 xzzy #
inherited from Vector3
Vector4 get xzzy => new Vector4(storage[0], storage[2], storage[2], storage[1]);
final Vector4 xzzz #
inherited from Vector3
Vector4 get xzzz => new Vector4(storage[0], storage[2], storage[2], storage[2]);
double y #
inherited from Vector3
double get y => storage[1];
set y(double arg) => storage[1] = arg;
Vector2 yx #
inherited from Vector3
Vector2 get yx => new Vector2(storage[1], storage[0]);
set yx(Vector2 arg) {
storage[1] = arg.storage[0];
storage[0] = arg.storage[1];
}
final Vector3 yxx #
inherited from Vector3
Vector3 get yxx => new Vector3(storage[1], storage[0], storage[0]);
final Vector4 yxxx #
inherited from Vector3
Vector4 get yxxx => new Vector4(storage[1], storage[0], storage[0], storage[0]);
final Vector4 yxxy #
inherited from Vector3
Vector4 get yxxy => new Vector4(storage[1], storage[0], storage[0], storage[1]);
final Vector4 yxxz #
inherited from Vector3
Vector4 get yxxz => new Vector4(storage[1], storage[0], storage[0], storage[2]);
final Vector3 yxy #
inherited from Vector3
Vector3 get yxy => new Vector3(storage[1], storage[0], storage[1]);
final Vector4 yxyx #
inherited from Vector3
Vector4 get yxyx => new Vector4(storage[1], storage[0], storage[1], storage[0]);
final Vector4 yxyy #
inherited from Vector3
Vector4 get yxyy => new Vector4(storage[1], storage[0], storage[1], storage[1]);
final Vector4 yxyz #
inherited from Vector3
Vector4 get yxyz => new Vector4(storage[1], storage[0], storage[1], storage[2]);
Vector3 yxz #
inherited from Vector3
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];
}
final Vector4 yxzx #
inherited from Vector3
Vector4 get yxzx => new Vector4(storage[1], storage[0], storage[2], storage[0]);
final Vector4 yxzy #
inherited from Vector3
Vector4 get yxzy => new Vector4(storage[1], storage[0], storage[2], storage[1]);
final Vector4 yxzz #
inherited from Vector3
Vector4 get yxzz => new Vector4(storage[1], storage[0], storage[2], storage[2]);
final Vector3 yyx #
inherited from Vector3
Vector3 get yyx => new Vector3(storage[1], storage[1], storage[0]);
final Vector4 yyxx #
inherited from Vector3
Vector4 get yyxx => new Vector4(storage[1], storage[1], storage[0], storage[0]);
final Vector4 yyxy #
inherited from Vector3
Vector4 get yyxy => new Vector4(storage[1], storage[1], storage[0], storage[1]);
final Vector4 yyxz #
inherited from Vector3
Vector4 get yyxz => new Vector4(storage[1], storage[1], storage[0], storage[2]);
final Vector3 yyy #
inherited from Vector3
Vector3 get yyy => new Vector3(storage[1], storage[1], storage[1]);
final Vector4 yyyx #
inherited from Vector3
Vector4 get yyyx => new Vector4(storage[1], storage[1], storage[1], storage[0]);
final Vector4 yyyy #
inherited from Vector3
Vector4 get yyyy => new Vector4(storage[1], storage[1], storage[1], storage[1]);
final Vector4 yyyz #
inherited from Vector3
Vector4 get yyyz => new Vector4(storage[1], storage[1], storage[1], storage[2]);
final Vector3 yyz #
inherited from Vector3
Vector3 get yyz => new Vector3(storage[1], storage[1], storage[2]);
final Vector4 yyzx #
inherited from Vector3
Vector4 get yyzx => new Vector4(storage[1], storage[1], storage[2], storage[0]);
final Vector4 yyzy #
inherited from Vector3
Vector4 get yyzy => new Vector4(storage[1], storage[1], storage[2], storage[1]);
final Vector4 yyzz #
inherited from Vector3
Vector4 get yyzz => new Vector4(storage[1], storage[1], storage[2], storage[2]);
Vector2 yz #
inherited from Vector3
Vector2 get yz => new Vector2(storage[1], storage[2]);
set yz(Vector2 arg) {
storage[1] = arg.storage[0];
storage[2] = arg.storage[1];
}
Vector3 yzx #
inherited from Vector3
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];
}
final Vector4 yzxx #
inherited from Vector3
Vector4 get yzxx => new Vector4(storage[1], storage[2], storage[0], storage[0]);
final Vector4 yzxy #
inherited from Vector3
Vector4 get yzxy => new Vector4(storage[1], storage[2], storage[0], storage[1]);
final Vector4 yzxz #
inherited from Vector3
Vector4 get yzxz => new Vector4(storage[1], storage[2], storage[0], storage[2]);
final Vector3 yzy #
inherited from Vector3
Vector3 get yzy => new Vector3(storage[1], storage[2], storage[1]);
final Vector4 yzyx #
inherited from Vector3
Vector4 get yzyx => new Vector4(storage[1], storage[2], storage[1], storage[0]);
final Vector4 yzyy #
inherited from Vector3
Vector4 get yzyy => new Vector4(storage[1], storage[2], storage[1], storage[1]);
final Vector4 yzyz #
inherited from Vector3
Vector4 get yzyz => new Vector4(storage[1], storage[2], storage[1], storage[2]);
final Vector3 yzz #
inherited from Vector3
Vector3 get yzz => new Vector3(storage[1], storage[2], storage[2]);
final Vector4 yzzx #
inherited from Vector3
Vector4 get yzzx => new Vector4(storage[1], storage[2], storage[2], storage[0]);
final Vector4 yzzy #
inherited from Vector3
Vector4 get yzzy => new Vector4(storage[1], storage[2], storage[2], storage[1]);
final Vector4 yzzz #
inherited from Vector3
Vector4 get yzzz => new Vector4(storage[1], storage[2], storage[2], storage[2]);
double z #
inherited from Vector3
double get z => storage[2];
set z(double arg) => storage[2] = arg;
Vector2 zx #
inherited from Vector3
Vector2 get zx => new Vector2(storage[2], storage[0]);
set zx(Vector2 arg) {
storage[2] = arg.storage[0];
storage[0] = arg.storage[1];
}
final Vector3 zxx #
inherited from Vector3
Vector3 get zxx => new Vector3(storage[2], storage[0], storage[0]);
final Vector4 zxxx #
inherited from Vector3
Vector4 get zxxx => new Vector4(storage[2], storage[0], storage[0], storage[0]);
final Vector4 zxxy #
inherited from Vector3
Vector4 get zxxy => new Vector4(storage[2], storage[0], storage[0], storage[1]);
final Vector4 zxxz #
inherited from Vector3
Vector4 get zxxz => new Vector4(storage[2], storage[0], storage[0], storage[2]);
Vector3 zxy #
inherited from Vector3
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];
}
final Vector4 zxyx #
inherited from Vector3
Vector4 get zxyx => new Vector4(storage[2], storage[0], storage[1], storage[0]);
final Vector4 zxyy #
inherited from Vector3
Vector4 get zxyy => new Vector4(storage[2], storage[0], storage[1], storage[1]);
final Vector4 zxyz #
inherited from Vector3
Vector4 get zxyz => new Vector4(storage[2], storage[0], storage[1], storage[2]);
final Vector3 zxz #
inherited from Vector3
Vector3 get zxz => new Vector3(storage[2], storage[0], storage[2]);
final Vector4 zxzx #
inherited from Vector3
Vector4 get zxzx => new Vector4(storage[2], storage[0], storage[2], storage[0]);
final Vector4 zxzy #
inherited from Vector3
Vector4 get zxzy => new Vector4(storage[2], storage[0], storage[2], storage[1]);
final Vector4 zxzz #
inherited from Vector3
Vector4 get zxzz => new Vector4(storage[2], storage[0], storage[2], storage[2]);
Vector2 zy #
inherited from Vector3
Vector2 get zy => new Vector2(storage[2], storage[1]);
set zy(Vector2 arg) {
storage[2] = arg.storage[0];
storage[1] = arg.storage[1];
}
Vector3 zyx #
inherited from Vector3
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];
}
final Vector4 zyxx #
inherited from Vector3
Vector4 get zyxx => new Vector4(storage[2], storage[1], storage[0], storage[0]);
final Vector4 zyxy #
inherited from Vector3
Vector4 get zyxy => new Vector4(storage[2], storage[1], storage[0], storage[1]);
final Vector4 zyxz #
inherited from Vector3
Vector4 get zyxz => new Vector4(storage[2], storage[1], storage[0], storage[2]);
final Vector3 zyy #
inherited from Vector3
Vector3 get zyy => new Vector3(storage[2], storage[1], storage[1]);
final Vector4 zyyx #
inherited from Vector3
Vector4 get zyyx => new Vector4(storage[2], storage[1], storage[1], storage[0]);
final Vector4 zyyy #
inherited from Vector3
Vector4 get zyyy => new Vector4(storage[2], storage[1], storage[1], storage[1]);
final Vector4 zyyz #
inherited from Vector3
Vector4 get zyyz => new Vector4(storage[2], storage[1], storage[1], storage[2]);
final Vector3 zyz #
inherited from Vector3
Vector3 get zyz => new Vector3(storage[2], storage[1], storage[2]);
final Vector4 zyzx #
inherited from Vector3
Vector4 get zyzx => new Vector4(storage[2], storage[1], storage[2], storage[0]);
final Vector4 zyzy #
inherited from Vector3
Vector4 get zyzy => new Vector4(storage[2], storage[1], storage[2], storage[1]);
final Vector4 zyzz #
inherited from Vector3
Vector4 get zyzz => new Vector4(storage[2], storage[1], storage[2], storage[2]);
final Vector3 zzx #
inherited from Vector3
Vector3 get zzx => new Vector3(storage[2], storage[2], storage[0]);
final Vector4 zzxx #
inherited from Vector3
Vector4 get zzxx => new Vector4(storage[2], storage[2], storage[0], storage[0]);
final Vector4 zzxy #
inherited from Vector3
Vector4 get zzxy => new Vector4(storage[2], storage[2], storage[0], storage[1]);
final Vector4 zzxz #
inherited from Vector3
Vector4 get zzxz => new Vector4(storage[2], storage[2], storage[0], storage[2]);
final Vector3 zzy #
inherited from Vector3
Vector3 get zzy => new Vector3(storage[2], storage[2], storage[1]);
final Vector4 zzyx #
inherited from Vector3
Vector4 get zzyx => new Vector4(storage[2], storage[2], storage[1], storage[0]);
final Vector4 zzyy #
inherited from Vector3
Vector4 get zzyy => new Vector4(storage[2], storage[2], storage[1], storage[1]);
final Vector4 zzyz #
inherited from Vector3
Vector4 get zzyz => new Vector4(storage[2], storage[2], storage[1], storage[2]);
final Vector3 zzz #
inherited from Vector3
Vector3 get zzz => new Vector3(storage[2], storage[2], storage[2]);
final Vector4 zzzx #
inherited from Vector3
Vector4 get zzzx => new Vector4(storage[2], storage[2], storage[2], storage[0]);
Operators
void operator []=(int i, double v) #
inherited from Vector3
void operator[]=(int i, double v) { storage[i] = v; }
Vector3 operator +(Vector3 other) #
inherited from Vector3
Add two vectors.
Vector3 operator+(Vector3 other) => new Vector3(storage[0] + other.storage[0],
storage[1] + other.storage[1],
storage[2] + other.storage[2]);
Vector3 operator -() #
inherited from Vector3
Negate
Vector3 operator-() => new Vector3(- storage[0], - storage[1], - storage[2]);
Vector3 operator -(Vector3 other) #
inherited from Vector3
Subtract two vectors.
Vector3 operator-(Vector3 other) => new Vector3(storage[0] - other.storage[0],
storage[1] - other.storage[1],
storage[2] - other.storage[2]);
Methods
Vector3 absolute() #
inherited from Vector3
Absolute value.
Vector3 absolute() {
storage[0] = storage[0].abs();
storage[1] = storage[1].abs();
storage[2] = storage[2].abs();
return this;
}
double absoluteError(Vector3 correct) #
inherited from Vector3
Absolute error between this and
correct
double absoluteError(Vector3 correct) {
return (this - correct).length;
}
Vector3 add(Vector3 arg) #
inherited from Vector3
Add
arg to this.
Vector3 add(Vector3 arg) {
storage[0] = storage[0] + arg.storage[0];
storage[1] = storage[1] + arg.storage[1];
storage[2] = storage[2] + arg.storage[2];
return this;
}
Vector3 applyProjection(Matrix4 arg) #
inherited from Vector3
Projects this using the projection matrix
arg
Vector3 applyProjection(Matrix4 arg) {
double _x = storage[0];
double _y = storage[1];
double _z = storage[2];
double d = 1.0 / (arg.storage[3] * _x + arg.storage[7] * _y
+ arg.storage[11] * _z + arg.storage[15]);
storage[0] = (arg.storage[0] * _x + arg.storage[4] * _y
+ arg.storage[8] * _z + arg.storage[12]) * d;
storage[1] = (arg.storage[1] * _x + arg.storage[5] * _y
+ arg.storage[9] * _z + arg.storage[13]) * d;
storage[2] = (arg.storage[2] * _x + arg.storage[6] * _y
+ arg.storage[10] * _z + arg.storage[14]) * d;
return this;
}
Vector3 clone() #
inherited from Vector3
Clone of this.
Vector3 clone() {
return new Vector3.copy(this);
}
void copyFromArray(List<double> array, [int offset = 0]) #
inherited from Vector3
Copies elements from
array into this starting at
offset.
void copyFromArray(List<double> array, [int offset=0]) {
storage[2] = array[offset+2];
storage[1] = array[offset+1];
storage[0] = array[offset+0];
}
Vector3 copyInto(Vector3 arg) #
inherited from Vector3
Vector3 copyInto(Vector3 arg) {
arg.storage[0] = storage[0];
arg.storage[1] = storage[1];
arg.storage[2] = storage[2];
return arg;
}
void copyIntoArray(List<double> array, [int offset = 0]) #
inherited from Vector3
Copies this into
array starting at
offset.
void copyIntoArray(List<double> array, [int offset=0]) {
array[offset+2] = storage[2];
array[offset+1] = storage[1];
array[offset+0] = storage[0];
}
Vector3 cross(Vector3 other) #
inherited from Vector3
Cross product.
Vector3 cross(Vector3 other) {
double _x = storage[0];
double _y = storage[1];
double _z = storage[2];
double ox = other.storage[0];
double oy = other.storage[1];
double oz = other.storage[2];
return new Vector3(_y * oz - _z * oy, _z * ox - _x * oz, _x * oy - _y * ox);
}
Vector3 crossInto(Vector3 other, Vector3 out) #
inherited from Vector3
Cross product. Stores result in out.
Vector3 crossInto(Vector3 other, Vector3 out) {
double _x = storage[0];
double _y = storage[1];
double _z = storage[2];
double ox = other.storage[0];
double oy = other.storage[1];
double oz = other.storage[2];
out.storage[0] = _y * oz - _z * oy;
out.storage[1] = _z * ox - _x * oz;
out.storage[2] = _x * oy - _y * ox;
return out;
}
Vector3 divide(Vector3 arg) #
inherited from Vector3
Divide entries in this with entries in
arg.
Vector3 divide(Vector3 arg) {
storage[0] = storage[0] / arg.storage[0];
storage[1] = storage[1] / arg.storage[1];
storage[2] = storage[2] / arg.storage[2];
return this;
}
double dot(Vector3 other) #
inherited from Vector3
Inner product.
double dot(Vector3 other) {
double sum;
sum = storage[0] * other.storage[0];
sum += storage[1] * other.storage[1];
sum += storage[2] * other.storage[2];
return sum;
}
Vector3 multiply(Vector3 arg) #
inherited from Vector3
Multiply entries in this with entries in
arg.
Vector3 multiply(Vector3 arg) {
storage[0] = storage[0] * arg.storage[0];
storage[1] = storage[1] * arg.storage[1];
storage[2] = storage[2] * arg.storage[2];
return this;
}
Vector3 negate() #
inherited from Vector3
Vector3 negate() {
storage[2] = -storage[2];
storage[1] = -storage[1];
storage[0] = -storage[0];
return this;
}
Vector3 normalize() #
inherited from Vector3
Normalizes this.
Vector3 normalize() {
double l = length;
if (l == 0.0) {
return this;
}
l = 1.0 / l;
storage[0] *= l;
storage[1] *= l;
storage[2] *= l;
return this;
}
Vector3 normalized() #
inherited from Vector3
Normalizes copy of this.
Vector3 normalized() {
return new Vector3.copy(this).normalize();
}
Vector3 normalizeInto(Vector3 out) #
inherited from Vector3
Normalize vector into out.
Vector3 normalizeInto(Vector3 out) {
out.setFrom(this);
return out.normalize();
}
double normalizeLength() #
inherited from Vector3
Normalize 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;
return l;
}
Vector3 reflect(Vector3 normal) #
inherited from Vector3
Reflect this.
Vector3 reflect(Vector3 normal) {
sub(normal.scaled(2 * normal.dot(this)));
return this;
}
Vector3 reflected(Vector3 normal) #
inherited from Vector3
Reflected copy of this.
Vector3 reflected(Vector3 normal) {
return new Vector3.copy(this).reflect(normal);
}
double relativeError(Vector3 correct) #
inherited from Vector3
Relative error between this and
correct
double relativeError(Vector3 correct) {
double correct_norm = correct.length;
double diff_norm = (this - correct).length;
return diff_norm/correct_norm;
}
Vector3 scale(double arg) #
inherited from Vector3
Scale this.
Vector3 scale(double arg) {
storage[2] = storage[2] * arg;
storage[1] = storage[1] * arg;
storage[0] = storage[0] * arg;
return this;
}
Vector3 scaled(double arg) #
inherited from Vector3
Vector3 scaled(double arg) {
return clone().scale(arg);
}
Vector3 setFrom(Vector3 other) #
inherited from Vector3
Set the values by copying them from other.
Vector3 setFrom(Vector3 other) {
storage[0] = other.storage[0];
storage[1] = other.storage[1];
storage[2] = other.storage[2];
return this;
}
Vector3 setValues(double x_, double y_, double z_) #
inherited from Vector3
Set the values of the vector.
Vector3 setValues(double x_, double y_, double z_) {
storage[0] = x_;
storage[1] = y_;
storage[2] = z_;
return this;
}
Vector3 setZero() #
inherited from Vector3
Zero vector.
Vector3 setZero() {
storage[2] = 0.0;
storage[1] = 0.0;
storage[0] = 0.0;
return this;
}
Vector3 splat(double arg) #
inherited from Vector3
Splat arg into all lanes of the vector.
Vector3 splat(double arg) {
storage[2] = arg;
storage[1] = arg;
storage[0] = arg;
return this;
}