Dart Documentationvector_mathvec3

vec3 class

class vec3 {
 double x;
 double y;
 double z;
 /// Constructs a new [vec3]. Follows GLSL constructor syntax so many combinations are possible
 vec3([dynamic x_, dynamic y_, dynamic z_]) {
   x = y = z = 0.0;
   if (x_ is vec2 && y_ is num) {
     this.xy = x_.xy;
     this.z = y_.toDouble();
     return;
   }
   if (x_ is num && y_ is vec2) {
     this.x = x_.toDouble();
     this.yz = y_.xy;
     return;
   }
   if (x_ is vec2 && y_ == null) {
     this.xy = x_.xy;
     this.z = 0.0;
     return;
   }
   if (x_ is vec3) {
     xyz = x_.xyz;
     return;
   }
   if (x_ is num && y_ is num && z_ is num) {
     x = x_.toDouble();
     y = y_.toDouble();
     z = z_.toDouble();
     return;
   }
   if (x_ is num) {
     x = y = z = x_.toDouble();
     return;
   }
 }
 /// Constructs a new [vec3] zero vector.
 vec3.zero() { makeZero(); }
 /// Make [this] the zero vector.
 vec3 makeZero() {
   x = 0.0;
   y = 0.0;
   z = 0.0;
   return this;
 }
 /// Constructs a copy of [other].
 vec3.copy(vec3 other) {
   makeCopy(other);
 }
 /// Make [this] a copy of [other] [other].
 vec3 makeCopy(vec3 other) {
   x = other.x;
   y = other.y;
   z = other.z;
   return this;
 }
 /// Constructs a new [vec3] that is initialized with passed in values.
 vec3.raw(num x_, num y_, num z_) {
   makeRaw(x_, y_, z_);
 }
 /// Components of [this] are set to the passed in values.
 vec3 makeRaw(num x_, num y_, num z_) {
   x = x_.toDouble();
   y = y_.toDouble();
   z = z_.toDouble();
   return this;
 }
 /// Constructs a new [vec3] that is initialized with values from [array] starting at [offset].
 vec3.array(List<num> array, [int offset=0]) {
   int i = offset;
   x = array[i].toDouble();
   i++;
   y = array[i].toDouble();
   i++;
   z = array[i].toDouble();
   i++;
 }
 /// Splats a scalar into all lanes of the vector.
 vec3 splat(num arg) {
   double a = arg.toDouble();
   x = a;
   y = a;
   z = a;
   return this;
 }
 /// Returns a printable string
 String toString() => '$x,$y,$z';
 /// Returns a new vec3 from -this
 vec3 operator-() => new vec3.raw(-x, -y, -z);
 /// Returns a new vec3 from this - [other]
 vec3 operator-(vec3 other) => new vec3.raw(x - other.x, y - other.y, z - other.z);
 /// Returns a new vec3 from this + [other]
 vec3 operator+(vec3 other) => new vec3.raw(x + other.x, y + other.y, z + other.z);
 /// Returns a new vec3 divided by [other]
 vec3 operator/(dynamic other) {
   if (other is num) {
     var o = 1.0 / other.toDouble();
     return new vec3.raw(x * o, y * o, z * o);
   }
   if (other is vec3) {
     return new vec3.raw(x / other.x, y / other.y, z / other.z);
   }
 }
 /// Returns a new vec3 scaled by [other]
 vec3 operator*(dynamic other) {
   if (other is num) {
     var o = other.toDouble();
     return new vec3.raw(x * o, y * o, z * o);
   }
   if (other is vec3) {
     return new vec3.raw(x * other.x, y * other.y, z * other.z);
   }
 }
 /// Returns a component from vec3. This is indexed as an array with [i]
 double operator[](int i) {
   assert(i >= 0 && i < 3);
   switch (i) {
     case 0: return x;
     case 1: return y;
     case 2: return z;
   };
   return 0.0;
 }
 /// Assigns a component in vec3 the value in [v]. This is indexed as an array with [i]
 void operator[]=(int i, double v) {
   assert(i >= 0 && i < 3);
   switch (i) {
     case 0: x = v; break;
     case 1: y = v; break;
     case 2: z = v; break;
   };
 }
 /// Returns length of this
 double get length {
   double sum = 0.0;
   sum += (x * x);
   sum += (y * y);
   sum += (z * z);
   return Math.sqrt(sum);
 }
 /// Returns squared length of this
 double get length2 {
   double sum = 0.0;
   sum += (x * x);
   sum += (y * y);
   sum += (z * z);
   return sum;
 }
 /// Normalizes [this]. Returns [this].
 vec3 normalize() {
   double l = length;
   if (l == 0.0) {
     return this;
   }
   x /= l;
   y /= l;
   z /= l;
   return this;
 }
 /// Normalizes [this]. Returns length.
 double normalizeLength() {
   double l = length;
   if (l == 0.0) {
     return 0.0;
   }
   x /= l;
   y /= l;
   z /= l;
   return l;
 }
 /// Normalizes [this] returns new vector or optional [out]
 vec3 normalized([vec3 out = null]) {
   if (out == null) {
     out = new vec3.raw(x, y, z);
   }
   double l = out.length;
   if (l == 0.0) {
     return out;
   }
   out.x /= l;
   out.y /= l;
   out.z /= l;
   return out;
 }
 /// Returns the dot product of [this] and [other]
 double dot(vec3 other) {
   double sum = 0.0;
   sum += (x * other.x);
   sum += (y * other.y);
   sum += (z * other.z);
   return sum;
 }
 /// Returns the cross product of [this] and [other], optionally pass in output storage [out]
 vec3 cross(vec3 other, [vec3 out=null]) {
   if (out == null) {
     out = new vec3.zero();
   }
   out.x = y * other.z - z * other.y;
   out.y = z * other.x - x * other.z;
   out.z = x * other.y - y * other.x;
   return out;
 }
 /// Returns the relative error between [this] and [correct]
 double relativeError(vec3 correct) {
   double correct_norm = correct.length;
   double diff_norm = (this - correct).length;
   return diff_norm/correct_norm;
 }
 /// Returns the absolute error between [this] and [correct]
 double absoluteError(vec3 correct) {
   return (this - correct).length;
 }
 set xy(vec2 arg) {
   x = arg.x;
   y = arg.y;
 }
 set xz(vec2 arg) {
   x = arg.x;
   z = arg.y;
 }
 set yx(vec2 arg) {
   y = arg.x;
   x = arg.y;
 }
 set yz(vec2 arg) {
   y = arg.x;
   z = arg.y;
 }
 set zx(vec2 arg) {
   z = arg.x;
   x = arg.y;
 }
 set zy(vec2 arg) {
   z = arg.x;
   y = arg.y;
 }
 set xyz(vec3 arg) {
   x = arg.x;
   y = arg.y;
   z = arg.z;
 }
 set xzy(vec3 arg) {
   x = arg.x;
   z = arg.y;
   y = arg.z;
 }
 set yxz(vec3 arg) {
   y = arg.x;
   x = arg.y;
   z = arg.z;
 }
 set yzx(vec3 arg) {
   y = arg.x;
   z = arg.y;
   x = arg.z;
 }
 set zxy(vec3 arg) {
   z = arg.x;
   x = arg.y;
   y = arg.z;
 }
 set zyx(vec3 arg) {
   z = arg.x;
   y = arg.y;
   x = arg.z;
 }
 /// Returns true if any component is infinite.
 bool get isInfinite {
   bool is_infinite = false;
   is_infinite = is_infinite || x.isInfinite;
   is_infinite = is_infinite || y.isInfinite;
   is_infinite = is_infinite || z.isInfinite;
   return is_infinite;
 }
 /// Returns true if any component is NaN.
 bool get isNaN {
   bool is_nan = false;
   is_nan = is_nan || x.isNaN;
   is_nan = is_nan || y.isNaN;
   is_nan = is_nan || z.isNaN;
   return is_nan;
 }
 set r(double arg) => x = arg;
 set g(double arg) => y = arg;
 set b(double arg) => z = arg;
 set s(double arg) => x = arg;
 set t(double arg) => y = arg;
 set p(double arg) => z = arg;
 set rg(vec2 arg) {
   r = arg.r;
   g = arg.g;
 }
 set rb(vec2 arg) {
   r = arg.r;
   b = arg.g;
 }
 set gr(vec2 arg) {
   g = arg.r;
   r = arg.g;
 }
 set gb(vec2 arg) {
   g = arg.r;
   b = arg.g;
 }
 set br(vec2 arg) {
   b = arg.r;
   r = arg.g;
 }
 set bg(vec2 arg) {
   b = arg.r;
   g = arg.g;
 }
 set rgb(vec3 arg) {
   r = arg.r;
   g = arg.g;
   b = arg.b;
 }
 set rbg(vec3 arg) {
   r = arg.r;
   b = arg.g;
   g = arg.b;
 }
 set grb(vec3 arg) {
   g = arg.r;
   r = arg.g;
   b = arg.b;
 }
 set gbr(vec3 arg) {
   g = arg.r;
   b = arg.g;
   r = arg.b;
 }
 set brg(vec3 arg) {
   b = arg.r;
   r = arg.g;
   g = arg.b;
 }
 set bgr(vec3 arg) {
   b = arg.r;
   g = arg.g;
   r = arg.b;
 }
 set st(vec2 arg) {
   s = arg.s;
   t = arg.t;
 }
 set sp(vec2 arg) {
   s = arg.s;
   p = arg.t;
 }
 set ts(vec2 arg) {
   t = arg.s;
   s = arg.t;
 }
 set tp(vec2 arg) {
   t = arg.s;
   p = arg.t;
 }
 set ps(vec2 arg) {
   p = arg.s;
   s = arg.t;
 }
 set pt(vec2 arg) {
   p = arg.s;
   t = arg.t;
 }
 set stp(vec3 arg) {
   s = arg.s;
   t = arg.t;
   p = arg.p;
 }
 set spt(vec3 arg) {
   s = arg.s;
   p = arg.t;
   t = arg.p;
 }
 set tsp(vec3 arg) {
   t = arg.s;
   s = arg.t;
   p = arg.p;
 }
 set tps(vec3 arg) {
   t = arg.s;
   p = arg.t;
   s = arg.p;
 }
 set pst(vec3 arg) {
   p = arg.s;
   s = arg.t;
   t = arg.p;
 }
 set pts(vec3 arg) {
   p = arg.s;
   t = arg.t;
   s = arg.p;
 }
 vec2 get xx => new vec2(x, x);
 vec2 get xy => new vec2(x, y);
 vec2 get xz => new vec2(x, z);
 vec2 get yx => new vec2(y, x);
 vec2 get yy => new vec2(y, y);
 vec2 get yz => new vec2(y, z);
 vec2 get zx => new vec2(z, x);
 vec2 get zy => new vec2(z, y);
 vec2 get zz => new vec2(z, z);
 vec3 get xxx => new vec3(x, x, x);
 vec3 get xxy => new vec3(x, x, y);
 vec3 get xxz => new vec3(x, x, z);
 vec3 get xyx => new vec3(x, y, x);
 vec3 get xyy => new vec3(x, y, y);
 vec3 get xyz => new vec3(x, y, z);
 vec3 get xzx => new vec3(x, z, x);
 vec3 get xzy => new vec3(x, z, y);
 vec3 get xzz => new vec3(x, z, z);
 vec3 get yxx => new vec3(y, x, x);
 vec3 get yxy => new vec3(y, x, y);
 vec3 get yxz => new vec3(y, x, z);
 vec3 get yyx => new vec3(y, y, x);
 vec3 get yyy => new vec3(y, y, y);
 vec3 get yyz => new vec3(y, y, z);
 vec3 get yzx => new vec3(y, z, x);
 vec3 get yzy => new vec3(y, z, y);
 vec3 get yzz => new vec3(y, z, z);
 vec3 get zxx => new vec3(z, x, x);
 vec3 get zxy => new vec3(z, x, y);
 vec3 get zxz => new vec3(z, x, z);
 vec3 get zyx => new vec3(z, y, x);
 vec3 get zyy => new vec3(z, y, y);
 vec3 get zyz => new vec3(z, y, z);
 vec3 get zzx => new vec3(z, z, x);
 vec3 get zzy => new vec3(z, z, y);
 vec3 get zzz => new vec3(z, z, z);
 vec4 get xxxx => new vec4(x, x, x, x);
 vec4 get xxxy => new vec4(x, x, x, y);
 vec4 get xxxz => new vec4(x, x, x, z);
 vec4 get xxyx => new vec4(x, x, y, x);
 vec4 get xxyy => new vec4(x, x, y, y);
 vec4 get xxyz => new vec4(x, x, y, z);
 vec4 get xxzx => new vec4(x, x, z, x);
 vec4 get xxzy => new vec4(x, x, z, y);
 vec4 get xxzz => new vec4(x, x, z, z);
 vec4 get xyxx => new vec4(x, y, x, x);
 vec4 get xyxy => new vec4(x, y, x, y);
 vec4 get xyxz => new vec4(x, y, x, z);
 vec4 get xyyx => new vec4(x, y, y, x);
 vec4 get xyyy => new vec4(x, y, y, y);
 vec4 get xyyz => new vec4(x, y, y, z);
 vec4 get xyzx => new vec4(x, y, z, x);
 vec4 get xyzy => new vec4(x, y, z, y);
 vec4 get xyzz => new vec4(x, y, z, z);
 vec4 get xzxx => new vec4(x, z, x, x);
 vec4 get xzxy => new vec4(x, z, x, y);
 vec4 get xzxz => new vec4(x, z, x, z);
 vec4 get xzyx => new vec4(x, z, y, x);
 vec4 get xzyy => new vec4(x, z, y, y);
 vec4 get xzyz => new vec4(x, z, y, z);
 vec4 get xzzx => new vec4(x, z, z, x);
 vec4 get xzzy => new vec4(x, z, z, y);
 vec4 get xzzz => new vec4(x, z, z, z);
 vec4 get yxxx => new vec4(y, x, x, x);
 vec4 get yxxy => new vec4(y, x, x, y);
 vec4 get yxxz => new vec4(y, x, x, z);
 vec4 get yxyx => new vec4(y, x, y, x);
 vec4 get yxyy => new vec4(y, x, y, y);
 vec4 get yxyz => new vec4(y, x, y, z);
 vec4 get yxzx => new vec4(y, x, z, x);
 vec4 get yxzy => new vec4(y, x, z, y);
 vec4 get yxzz => new vec4(y, x, z, z);
 vec4 get yyxx => new vec4(y, y, x, x);
 vec4 get yyxy => new vec4(y, y, x, y);
 vec4 get yyxz => new vec4(y, y, x, z);
 vec4 get yyyx => new vec4(y, y, y, x);
 vec4 get yyyy => new vec4(y, y, y, y);
 vec4 get yyyz => new vec4(y, y, y, z);
 vec4 get yyzx => new vec4(y, y, z, x);
 vec4 get yyzy => new vec4(y, y, z, y);
 vec4 get yyzz => new vec4(y, y, z, z);
 vec4 get yzxx => new vec4(y, z, x, x);
 vec4 get yzxy => new vec4(y, z, x, y);
 vec4 get yzxz => new vec4(y, z, x, z);
 vec4 get yzyx => new vec4(y, z, y, x);
 vec4 get yzyy => new vec4(y, z, y, y);
 vec4 get yzyz => new vec4(y, z, y, z);
 vec4 get yzzx => new vec4(y, z, z, x);
 vec4 get yzzy => new vec4(y, z, z, y);
 vec4 get yzzz => new vec4(y, z, z, z);
 vec4 get zxxx => new vec4(z, x, x, x);
 vec4 get zxxy => new vec4(z, x, x, y);
 vec4 get zxxz => new vec4(z, x, x, z);
 vec4 get zxyx => new vec4(z, x, y, x);
 vec4 get zxyy => new vec4(z, x, y, y);
 vec4 get zxyz => new vec4(z, x, y, z);
 vec4 get zxzx => new vec4(z, x, z, x);
 vec4 get zxzy => new vec4(z, x, z, y);
 vec4 get zxzz => new vec4(z, x, z, z);
 vec4 get zyxx => new vec4(z, y, x, x);
 vec4 get zyxy => new vec4(z, y, x, y);
 vec4 get zyxz => new vec4(z, y, x, z);
 vec4 get zyyx => new vec4(z, y, y, x);
 vec4 get zyyy => new vec4(z, y, y, y);
 vec4 get zyyz => new vec4(z, y, y, z);
 vec4 get zyzx => new vec4(z, y, z, x);
 vec4 get zyzy => new vec4(z, y, z, y);
 vec4 get zyzz => new vec4(z, y, z, z);
 vec4 get zzxx => new vec4(z, z, x, x);
 vec4 get zzxy => new vec4(z, z, x, y);
 vec4 get zzxz => new vec4(z, z, x, z);
 vec4 get zzyx => new vec4(z, z, y, x);
 vec4 get zzyy => new vec4(z, z, y, y);
 vec4 get zzyz => new vec4(z, z, y, z);
 vec4 get zzzx => new vec4(z, z, z, x);
 vec4 get zzzy => new vec4(z, z, z, y);
 vec4 get zzzz => new vec4(z, z, z, z);
 double get r => x;
 double get g => y;
 double get b => z;
 double get s => x;
 double get t => y;
 double get p => z;
 vec2 get rr => new vec2(r, r);
 vec2 get rg => new vec2(r, g);
 vec2 get rb => new vec2(r, b);
 vec2 get gr => new vec2(g, r);
 vec2 get gg => new vec2(g, g);
 vec2 get gb => new vec2(g, b);
 vec2 get br => new vec2(b, r);
 vec2 get bg => new vec2(b, g);
 vec2 get bb => new vec2(b, b);
 vec3 get rrr => new vec3(r, r, r);
 vec3 get rrg => new vec3(r, r, g);
 vec3 get rrb => new vec3(r, r, b);
 vec3 get rgr => new vec3(r, g, r);
 vec3 get rgg => new vec3(r, g, g);
 vec3 get rgb => new vec3(r, g, b);
 vec3 get rbr => new vec3(r, b, r);
 vec3 get rbg => new vec3(r, b, g);
 vec3 get rbb => new vec3(r, b, b);
 vec3 get grr => new vec3(g, r, r);
 vec3 get grg => new vec3(g, r, g);
 vec3 get grb => new vec3(g, r, b);
 vec3 get ggr => new vec3(g, g, r);
 vec3 get ggg => new vec3(g, g, g);
 vec3 get ggb => new vec3(g, g, b);
 vec3 get gbr => new vec3(g, b, r);
 vec3 get gbg => new vec3(g, b, g);
 vec3 get gbb => new vec3(g, b, b);
 vec3 get brr => new vec3(b, r, r);
 vec3 get brg => new vec3(b, r, g);
 vec3 get brb => new vec3(b, r, b);
 vec3 get bgr => new vec3(b, g, r);
 vec3 get bgg => new vec3(b, g, g);
 vec3 get bgb => new vec3(b, g, b);
 vec3 get bbr => new vec3(b, b, r);
 vec3 get bbg => new vec3(b, b, g);
 vec3 get bbb => new vec3(b, b, b);
 vec4 get rrrr => new vec4(r, r, r, r);
 vec4 get rrrg => new vec4(r, r, r, g);
 vec4 get rrrb => new vec4(r, r, r, b);
 vec4 get rrgr => new vec4(r, r, g, r);
 vec4 get rrgg => new vec4(r, r, g, g);
 vec4 get rrgb => new vec4(r, r, g, b);
 vec4 get rrbr => new vec4(r, r, b, r);
 vec4 get rrbg => new vec4(r, r, b, g);
 vec4 get rrbb => new vec4(r, r, b, b);
 vec4 get rgrr => new vec4(r, g, r, r);
 vec4 get rgrg => new vec4(r, g, r, g);
 vec4 get rgrb => new vec4(r, g, r, b);
 vec4 get rggr => new vec4(r, g, g, r);
 vec4 get rggg => new vec4(r, g, g, g);
 vec4 get rggb => new vec4(r, g, g, b);
 vec4 get rgbr => new vec4(r, g, b, r);
 vec4 get rgbg => new vec4(r, g, b, g);
 vec4 get rgbb => new vec4(r, g, b, b);
 vec4 get rbrr => new vec4(r, b, r, r);
 vec4 get rbrg => new vec4(r, b, r, g);
 vec4 get rbrb => new vec4(r, b, r, b);
 vec4 get rbgr => new vec4(r, b, g, r);
 vec4 get rbgg => new vec4(r, b, g, g);
 vec4 get rbgb => new vec4(r, b, g, b);
 vec4 get rbbr => new vec4(r, b, b, r);
 vec4 get rbbg => new vec4(r, b, b, g);
 vec4 get rbbb => new vec4(r, b, b, b);
 vec4 get grrr => new vec4(g, r, r, r);
 vec4 get grrg => new vec4(g, r, r, g);
 vec4 get grrb => new vec4(g, r, r, b);
 vec4 get grgr => new vec4(g, r, g, r);
 vec4 get grgg => new vec4(g, r, g, g);
 vec4 get grgb => new vec4(g, r, g, b);
 vec4 get grbr => new vec4(g, r, b, r);
 vec4 get grbg => new vec4(g, r, b, g);
 vec4 get grbb => new vec4(g, r, b, b);
 vec4 get ggrr => new vec4(g, g, r, r);
 vec4 get ggrg => new vec4(g, g, r, g);
 vec4 get ggrb => new vec4(g, g, r, b);
 vec4 get gggr => new vec4(g, g, g, r);
 vec4 get gggg => new vec4(g, g, g, g);
 vec4 get gggb => new vec4(g, g, g, b);
 vec4 get ggbr => new vec4(g, g, b, r);
 vec4 get ggbg => new vec4(g, g, b, g);
 vec4 get ggbb => new vec4(g, g, b, b);
 vec4 get gbrr => new vec4(g, b, r, r);
 vec4 get gbrg => new vec4(g, b, r, g);
 vec4 get gbrb => new vec4(g, b, r, b);
 vec4 get gbgr => new vec4(g, b, g, r);
 vec4 get gbgg => new vec4(g, b, g, g);
 vec4 get gbgb => new vec4(g, b, g, b);
 vec4 get gbbr => new vec4(g, b, b, r);
 vec4 get gbbg => new vec4(g, b, b, g);
 vec4 get gbbb => new vec4(g, b, b, b);
 vec4 get brrr => new vec4(b, r, r, r);
 vec4 get brrg => new vec4(b, r, r, g);
 vec4 get brrb => new vec4(b, r, r, b);
 vec4 get brgr => new vec4(b, r, g, r);
 vec4 get brgg => new vec4(b, r, g, g);
 vec4 get brgb => new vec4(b, r, g, b);
 vec4 get brbr => new vec4(b, r, b, r);
 vec4 get brbg => new vec4(b, r, b, g);
 vec4 get brbb => new vec4(b, r, b, b);
 vec4 get bgrr => new vec4(b, g, r, r);
 vec4 get bgrg => new vec4(b, g, r, g);
 vec4 get bgrb => new vec4(b, g, r, b);
 vec4 get bggr => new vec4(b, g, g, r);
 vec4 get bggg => new vec4(b, g, g, g);
 vec4 get bggb => new vec4(b, g, g, b);
 vec4 get bgbr => new vec4(b, g, b, r);
 vec4 get bgbg => new vec4(b, g, b, g);
 vec4 get bgbb => new vec4(b, g, b, b);
 vec4 get bbrr => new vec4(b, b, r, r);
 vec4 get bbrg => new vec4(b, b, r, g);
 vec4 get bbrb => new vec4(b, b, r, b);
 vec4 get bbgr => new vec4(b, b, g, r);
 vec4 get bbgg => new vec4(b, b, g, g);
 vec4 get bbgb => new vec4(b, b, g, b);
 vec4 get bbbr => new vec4(b, b, b, r);
 vec4 get bbbg => new vec4(b, b, b, g);
 vec4 get bbbb => new vec4(b, b, b, b);
 vec2 get ss => new vec2(s, s);
 vec2 get st => new vec2(s, t);
 vec2 get sp => new vec2(s, p);
 vec2 get ts => new vec2(t, s);
 vec2 get tt => new vec2(t, t);
 vec2 get tp => new vec2(t, p);
 vec2 get ps => new vec2(p, s);
 vec2 get pt => new vec2(p, t);
 vec2 get pp => new vec2(p, p);
 vec3 get sss => new vec3(s, s, s);
 vec3 get sst => new vec3(s, s, t);
 vec3 get ssp => new vec3(s, s, p);
 vec3 get sts => new vec3(s, t, s);
 vec3 get stt => new vec3(s, t, t);
 vec3 get stp => new vec3(s, t, p);
 vec3 get sps => new vec3(s, p, s);
 vec3 get spt => new vec3(s, p, t);
 vec3 get spp => new vec3(s, p, p);
 vec3 get tss => new vec3(t, s, s);
 vec3 get tst => new vec3(t, s, t);
 vec3 get tsp => new vec3(t, s, p);
 vec3 get tts => new vec3(t, t, s);
 vec3 get ttt => new vec3(t, t, t);
 vec3 get ttp => new vec3(t, t, p);
 vec3 get tps => new vec3(t, p, s);
 vec3 get tpt => new vec3(t, p, t);
 vec3 get tpp => new vec3(t, p, p);
 vec3 get pss => new vec3(p, s, s);
 vec3 get pst => new vec3(p, s, t);
 vec3 get psp => new vec3(p, s, p);
 vec3 get pts => new vec3(p, t, s);
 vec3 get ptt => new vec3(p, t, t);
 vec3 get ptp => new vec3(p, t, p);
 vec3 get pps => new vec3(p, p, s);
 vec3 get ppt => new vec3(p, p, t);
 vec3 get ppp => new vec3(p, p, p);
 vec4 get ssss => new vec4(s, s, s, s);
 vec4 get ssst => new vec4(s, s, s, t);
 vec4 get sssp => new vec4(s, s, s, p);
 vec4 get ssts => new vec4(s, s, t, s);
 vec4 get sstt => new vec4(s, s, t, t);
 vec4 get sstp => new vec4(s, s, t, p);
 vec4 get ssps => new vec4(s, s, p, s);
 vec4 get sspt => new vec4(s, s, p, t);
 vec4 get sspp => new vec4(s, s, p, p);
 vec4 get stss => new vec4(s, t, s, s);
 vec4 get stst => new vec4(s, t, s, t);
 vec4 get stsp => new vec4(s, t, s, p);
 vec4 get stts => new vec4(s, t, t, s);
 vec4 get sttt => new vec4(s, t, t, t);
 vec4 get sttp => new vec4(s, t, t, p);
 vec4 get stps => new vec4(s, t, p, s);
 vec4 get stpt => new vec4(s, t, p, t);
 vec4 get stpp => new vec4(s, t, p, p);
 vec4 get spss => new vec4(s, p, s, s);
 vec4 get spst => new vec4(s, p, s, t);
 vec4 get spsp => new vec4(s, p, s, p);
 vec4 get spts => new vec4(s, p, t, s);
 vec4 get sptt => new vec4(s, p, t, t);
 vec4 get sptp => new vec4(s, p, t, p);
 vec4 get spps => new vec4(s, p, p, s);
 vec4 get sppt => new vec4(s, p, p, t);
 vec4 get sppp => new vec4(s, p, p, p);
 vec4 get tsss => new vec4(t, s, s, s);
 vec4 get tsst => new vec4(t, s, s, t);
 vec4 get tssp => new vec4(t, s, s, p);
 vec4 get tsts => new vec4(t, s, t, s);
 vec4 get tstt => new vec4(t, s, t, t);
 vec4 get tstp => new vec4(t, s, t, p);
 vec4 get tsps => new vec4(t, s, p, s);
 vec4 get tspt => new vec4(t, s, p, t);
 vec4 get tspp => new vec4(t, s, p, p);
 vec4 get ttss => new vec4(t, t, s, s);
 vec4 get ttst => new vec4(t, t, s, t);
 vec4 get ttsp => new vec4(t, t, s, p);
 vec4 get ttts => new vec4(t, t, t, s);
 vec4 get tttt => new vec4(t, t, t, t);
 vec4 get tttp => new vec4(t, t, t, p);
 vec4 get ttps => new vec4(t, t, p, s);
 vec4 get ttpt => new vec4(t, t, p, t);
 vec4 get ttpp => new vec4(t, t, p, p);
 vec4 get tpss => new vec4(t, p, s, s);
 vec4 get tpst => new vec4(t, p, s, t);
 vec4 get tpsp => new vec4(t, p, s, p);
 vec4 get tpts => new vec4(t, p, t, s);
 vec4 get tptt => new vec4(t, p, t, t);
 vec4 get tptp => new vec4(t, p, t, p);
 vec4 get tpps => new vec4(t, p, p, s);
 vec4 get tppt => new vec4(t, p, p, t);
 vec4 get tppp => new vec4(t, p, p, p);
 vec4 get psss => new vec4(p, s, s, s);
 vec4 get psst => new vec4(p, s, s, t);
 vec4 get pssp => new vec4(p, s, s, p);
 vec4 get psts => new vec4(p, s, t, s);
 vec4 get pstt => new vec4(p, s, t, t);
 vec4 get pstp => new vec4(p, s, t, p);
 vec4 get psps => new vec4(p, s, p, s);
 vec4 get pspt => new vec4(p, s, p, t);
 vec4 get pspp => new vec4(p, s, p, p);
 vec4 get ptss => new vec4(p, t, s, s);
 vec4 get ptst => new vec4(p, t, s, t);
 vec4 get ptsp => new vec4(p, t, s, p);
 vec4 get ptts => new vec4(p, t, t, s);
 vec4 get pttt => new vec4(p, t, t, t);
 vec4 get pttp => new vec4(p, t, t, p);
 vec4 get ptps => new vec4(p, t, p, s);
 vec4 get ptpt => new vec4(p, t, p, t);
 vec4 get ptpp => new vec4(p, t, p, p);
 vec4 get ppss => new vec4(p, p, s, s);
 vec4 get ppst => new vec4(p, p, s, t);
 vec4 get ppsp => new vec4(p, p, s, p);
 vec4 get ppts => new vec4(p, p, t, s);
 vec4 get pptt => new vec4(p, p, t, t);
 vec4 get pptp => new vec4(p, p, t, p);
 vec4 get ppps => new vec4(p, p, p, s);
 vec4 get pppt => new vec4(p, p, p, t);
 vec4 get pppp => new vec4(p, p, p, p);
 vec3 add(vec3 arg) {
   x = x + arg.x;
   y = y + arg.y;
   z = z + arg.z;
   return this;
 }
 vec3 sub(vec3 arg) {
   x = x - arg.x;
   y = y - arg.y;
   z = z - arg.z;
   return this;
 }
 vec3 multiply(vec3 arg) {
   x = x * arg.x;
   y = y * arg.y;
   z = z * arg.z;
   return this;
 }
 vec3 div(vec3 arg) {
   x = x / arg.x;
   y = y / arg.y;
   z = z / arg.z;
   return this;
 }
 vec3 scale(num arg) {
   double a = arg.toDouble();
   x = x * a;
   y = y * a;
   z = z * a;
   return this;
 }
 vec3 scaled(num arg) {
   return clone().scale(arg);
 }
 vec3 negate() {
   x = -x;
   y = -y;
   z = -z;
   return this;
 }
 vec3 absolute() {
   x = x.abs();
   y = y.abs();
   z = z.abs();
   return this;
 }
 vec3 clone() {
   return new vec3.copy(this);
 }
 vec3 copyInto(vec3 arg) {
   arg.x = x;
   arg.y = y;
   arg.z = z;
   return arg;
 }
 vec3 copyFrom(vec3 arg) {
   x = arg.x;
   y = arg.y;
   z = arg.z;
   return this;
 }
 vec3 set(vec3 arg) {
   x = arg.x;
   y = arg.y;
   z = arg.z;
   return this;
 }
 vec3 setComponents(num x_, num y_, num z_) {
   x = x_.toDouble();
   y = y_.toDouble();
   z = z_.toDouble();
   return this;
 }
 /// Copies [this] into [array] starting at [offset].
 void copyIntoArray(List<num> array, [int offset=0]) {
   int i = offset;
   array[i] = x;
   i++;
   array[i] = y;
   i++;
   array[i] = z;
   i++;
 }
 /// Copies elements from [array] into [this] starting at [offset].
 void copyFromArray(List<num> array, [int offset=0]) {
   int i = offset;
   x = array[i].toDouble();
   i++;
   y = array[i].toDouble();
   i++;
   z = array[i].toDouble();
   i++;
 }
}

Constructors

new vec3([x_, y_, z_]) #

Constructs a new vec3. Follows GLSL constructor syntax so many combinations are possible

vec3([dynamic x_, dynamic y_, dynamic z_]) {
 x = y = z = 0.0;
 if (x_ is vec2 && y_ is num) {
   this.xy = x_.xy;
   this.z = y_.toDouble();
   return;
 }
 if (x_ is num && y_ is vec2) {
   this.x = x_.toDouble();
   this.yz = y_.xy;
   return;
 }
 if (x_ is vec2 && y_ == null) {
   this.xy = x_.xy;
   this.z = 0.0;
   return;
 }
 if (x_ is vec3) {
   xyz = x_.xyz;
   return;
 }
 if (x_ is num && y_ is num && z_ is num) {
   x = x_.toDouble();
   y = y_.toDouble();
   z = z_.toDouble();
   return;
 }
 if (x_ is num) {
   x = y = z = x_.toDouble();
   return;
 }
}

new vec3.array(List<num> array, [int offset = 0]) #

Constructs a new vec3 that is initialized with values from array starting at offset.

vec3.array(List<num> array, [int offset=0]) {
 int i = offset;
 x = array[i].toDouble();
 i++;
 y = array[i].toDouble();
 i++;
 z = array[i].toDouble();
 i++;
}

new vec3.copy(vec3 other) #

Constructs a copy of other.

vec3.copy(vec3 other) {
 makeCopy(other);
}

new vec3.raw(num x_, num y_, num z_) #

Constructs a new vec3 that is initialized with passed in values.

vec3.raw(num x_, num y_, num z_) {
 makeRaw(x_, y_, z_);
}

new vec3.zero() #

Constructs a new vec3 zero vector.

vec3.zero() { makeZero(); }

Properties

double b #

double get b => z;
set b(double arg) => z = arg;

final vec2 bb #

vec2 get bb => new vec2(b, b);

final vec3 bbb #

vec3 get bbb => new vec3(b, b, b);

final vec4 bbbb #

vec4 get bbbb => new vec4(b, b, b, b);

final vec4 bbbg #

vec4 get bbbg => new vec4(b, b, b, g);

final vec4 bbbr #

vec4 get bbbr => new vec4(b, b, b, r);

final vec3 bbg #

vec3 get bbg => new vec3(b, b, g);

final vec4 bbgb #

vec4 get bbgb => new vec4(b, b, g, b);

final vec4 bbgg #

vec4 get bbgg => new vec4(b, b, g, g);

final vec4 bbgr #

vec4 get bbgr => new vec4(b, b, g, r);

final vec3 bbr #

vec3 get bbr => new vec3(b, b, r);

final vec4 bbrb #

vec4 get bbrb => new vec4(b, b, r, b);

final vec4 bbrg #

vec4 get bbrg => new vec4(b, b, r, g);

final vec4 bbrr #

vec4 get bbrr => new vec4(b, b, r, r);

vec2 bg #

vec2 get bg => new vec2(b, g);
set bg(vec2 arg) {
 b = arg.r;
 g = arg.g;
}

final vec3 bgb #

vec3 get bgb => new vec3(b, g, b);

final vec4 bgbb #

vec4 get bgbb => new vec4(b, g, b, b);

final vec4 bgbg #

vec4 get bgbg => new vec4(b, g, b, g);

final vec4 bgbr #

vec4 get bgbr => new vec4(b, g, b, r);

final vec3 bgg #

vec3 get bgg => new vec3(b, g, g);

final vec4 bggb #

vec4 get bggb => new vec4(b, g, g, b);

final vec4 bggg #

vec4 get bggg => new vec4(b, g, g, g);

final vec4 bggr #

vec4 get bggr => new vec4(b, g, g, r);

vec3 bgr #

vec3 get bgr => new vec3(b, g, r);
set bgr(vec3 arg) {
 b = arg.r;
 g = arg.g;
 r = arg.b;
}

final vec4 bgrb #

vec4 get bgrb => new vec4(b, g, r, b);

final vec4 bgrg #

vec4 get bgrg => new vec4(b, g, r, g);

final vec4 bgrr #

vec4 get bgrr => new vec4(b, g, r, r);

vec2 br #

vec2 get br => new vec2(b, r);
set br(vec2 arg) {
 b = arg.r;
 r = arg.g;
}

final vec3 brb #

vec3 get brb => new vec3(b, r, b);

final vec4 brbb #

vec4 get brbb => new vec4(b, r, b, b);

final vec4 brbg #

vec4 get brbg => new vec4(b, r, b, g);

final vec4 brbr #

vec4 get brbr => new vec4(b, r, b, r);

vec3 brg #

vec3 get brg => new vec3(b, r, g);
set brg(vec3 arg) {
 b = arg.r;
 r = arg.g;
 g = arg.b;
}

final vec4 brgb #

vec4 get brgb => new vec4(b, r, g, b);

final vec4 brgg #

vec4 get brgg => new vec4(b, r, g, g);

final vec4 brgr #

vec4 get brgr => new vec4(b, r, g, r);

final vec3 brr #

vec3 get brr => new vec3(b, r, r);

final vec4 brrb #

vec4 get brrb => new vec4(b, r, r, b);

final vec4 brrg #

vec4 get brrg => new vec4(b, r, r, g);

final vec4 brrr #

vec4 get brrr => new vec4(b, r, r, r);

double g #

double get g => y;
set g(double arg) => y = arg;

vec2 gb #

vec2 get gb => new vec2(g, b);
set gb(vec2 arg) {
 g = arg.r;
 b = arg.g;
}

final vec3 gbb #

vec3 get gbb => new vec3(g, b, b);

final vec4 gbbb #

vec4 get gbbb => new vec4(g, b, b, b);

final vec4 gbbg #

vec4 get gbbg => new vec4(g, b, b, g);

final vec4 gbbr #

vec4 get gbbr => new vec4(g, b, b, r);

final vec3 gbg #

vec3 get gbg => new vec3(g, b, g);

final vec4 gbgb #

vec4 get gbgb => new vec4(g, b, g, b);

final vec4 gbgg #

vec4 get gbgg => new vec4(g, b, g, g);

final vec4 gbgr #

vec4 get gbgr => new vec4(g, b, g, r);

vec3 gbr #

vec3 get gbr => new vec3(g, b, r);
set gbr(vec3 arg) {
 g = arg.r;
 b = arg.g;
 r = arg.b;
}

final vec4 gbrb #

vec4 get gbrb => new vec4(g, b, r, b);

final vec4 gbrg #

vec4 get gbrg => new vec4(g, b, r, g);

final vec4 gbrr #

vec4 get gbrr => new vec4(g, b, r, r);

final vec2 gg #

vec2 get gg => new vec2(g, g);

final vec3 ggb #

vec3 get ggb => new vec3(g, g, b);

final vec4 ggbb #

vec4 get ggbb => new vec4(g, g, b, b);

final vec4 ggbg #

vec4 get ggbg => new vec4(g, g, b, g);

final vec4 ggbr #

vec4 get ggbr => new vec4(g, g, b, r);

final vec3 ggg #

vec3 get ggg => new vec3(g, g, g);

final vec4 gggb #

vec4 get gggb => new vec4(g, g, g, b);

final vec4 gggg #

vec4 get gggg => new vec4(g, g, g, g);

final vec4 gggr #

vec4 get gggr => new vec4(g, g, g, r);

final vec3 ggr #

vec3 get ggr => new vec3(g, g, r);

final vec4 ggrb #

vec4 get ggrb => new vec4(g, g, r, b);

final vec4 ggrg #

vec4 get ggrg => new vec4(g, g, r, g);

final vec4 ggrr #

vec4 get ggrr => new vec4(g, g, r, r);

vec2 gr #

vec2 get gr => new vec2(g, r);
set gr(vec2 arg) {
 g = arg.r;
 r = arg.g;
}

vec3 grb #

vec3 get grb => new vec3(g, r, b);
set grb(vec3 arg) {
 g = arg.r;
 r = arg.g;
 b = arg.b;
}

final vec4 grbb #

vec4 get grbb => new vec4(g, r, b, b);

final vec4 grbg #

vec4 get grbg => new vec4(g, r, b, g);

final vec4 grbr #

vec4 get grbr => new vec4(g, r, b, r);

final vec3 grg #

vec3 get grg => new vec3(g, r, g);

final vec4 grgb #

vec4 get grgb => new vec4(g, r, g, b);

final vec4 grgg #

vec4 get grgg => new vec4(g, r, g, g);

final vec4 grgr #

vec4 get grgr => new vec4(g, r, g, r);

final vec3 grr #

vec3 get grr => new vec3(g, r, r);

final vec4 grrb #

vec4 get grrb => new vec4(g, r, r, b);

final vec4 grrg #

vec4 get grrg => new vec4(g, r, r, g);

final vec4 grrr #

vec4 get grrr => new vec4(g, r, r, r);

final bool isInfinite #

Returns true if any component is infinite.

bool get isInfinite {
 bool is_infinite = false;
 is_infinite = is_infinite || x.isInfinite;
 is_infinite = is_infinite || y.isInfinite;
 is_infinite = is_infinite || z.isInfinite;
 return is_infinite;
}

final bool isNaN #

Returns true if any component is NaN.

bool get isNaN {
 bool is_nan = false;
 is_nan = is_nan || x.isNaN;
 is_nan = is_nan || y.isNaN;
 is_nan = is_nan || z.isNaN;
 return is_nan;
}

final double length #

Returns length of this

double get length {
 double sum = 0.0;
 sum += (x * x);
 sum += (y * y);
 sum += (z * z);
 return Math.sqrt(sum);
}

final double length2 #

Returns squared length of this

double get length2 {
 double sum = 0.0;
 sum += (x * x);
 sum += (y * y);
 sum += (z * z);
 return sum;
}

double p #

double get p => z;
set p(double arg) => z = arg;

final vec2 pp #

vec2 get pp => new vec2(p, p);

final vec3 ppp #

vec3 get ppp => new vec3(p, p, p);

final vec4 pppp #

vec4 get pppp => new vec4(p, p, p, p);

final vec4 ppps #

vec4 get ppps => new vec4(p, p, p, s);

final vec4 pppt #

vec4 get pppt => new vec4(p, p, p, t);

final vec3 pps #

vec3 get pps => new vec3(p, p, s);

final vec4 ppsp #

vec4 get ppsp => new vec4(p, p, s, p);

final vec4 ppss #

vec4 get ppss => new vec4(p, p, s, s);

final vec4 ppst #

vec4 get ppst => new vec4(p, p, s, t);

final vec3 ppt #

vec3 get ppt => new vec3(p, p, t);

final vec4 pptp #

vec4 get pptp => new vec4(p, p, t, p);

final vec4 ppts #

vec4 get ppts => new vec4(p, p, t, s);

final vec4 pptt #

vec4 get pptt => new vec4(p, p, t, t);

vec2 ps #

vec2 get ps => new vec2(p, s);
set ps(vec2 arg) {
 p = arg.s;
 s = arg.t;
}

final vec3 psp #

vec3 get psp => new vec3(p, s, p);

final vec4 pspp #

vec4 get pspp => new vec4(p, s, p, p);

final vec4 psps #

vec4 get psps => new vec4(p, s, p, s);

final vec4 pspt #

vec4 get pspt => new vec4(p, s, p, t);

final vec3 pss #

vec3 get pss => new vec3(p, s, s);

final vec4 pssp #

vec4 get pssp => new vec4(p, s, s, p);

final vec4 psss #

vec4 get psss => new vec4(p, s, s, s);

final vec4 psst #

vec4 get psst => new vec4(p, s, s, t);

vec3 pst #

vec3 get pst => new vec3(p, s, t);
set pst(vec3 arg) {
 p = arg.s;
 s = arg.t;
 t = arg.p;
}

final vec4 pstp #

vec4 get pstp => new vec4(p, s, t, p);

final vec4 psts #

vec4 get psts => new vec4(p, s, t, s);

final vec4 pstt #

vec4 get pstt => new vec4(p, s, t, t);

vec2 pt #

vec2 get pt => new vec2(p, t);
set pt(vec2 arg) {
 p = arg.s;
 t = arg.t;
}

final vec3 ptp #

vec3 get ptp => new vec3(p, t, p);

final vec4 ptpp #

vec4 get ptpp => new vec4(p, t, p, p);

final vec4 ptps #

vec4 get ptps => new vec4(p, t, p, s);

final vec4 ptpt #

vec4 get ptpt => new vec4(p, t, p, t);

vec3 pts #

vec3 get pts => new vec3(p, t, s);
set pts(vec3 arg) {
 p = arg.s;
 t = arg.t;
 s = arg.p;
}

final vec4 ptsp #

vec4 get ptsp => new vec4(p, t, s, p);

final vec4 ptss #

vec4 get ptss => new vec4(p, t, s, s);

final vec4 ptst #

vec4 get ptst => new vec4(p, t, s, t);

final vec3 ptt #

vec3 get ptt => new vec3(p, t, t);

final vec4 pttp #

vec4 get pttp => new vec4(p, t, t, p);

final vec4 ptts #

vec4 get ptts => new vec4(p, t, t, s);

final vec4 pttt #

vec4 get pttt => new vec4(p, t, t, t);

double r #

double get r => x;
set r(double arg) => x = arg;

vec2 rb #

vec2 get rb => new vec2(r, b);
set rb(vec2 arg) {
 r = arg.r;
 b = arg.g;
}

final vec3 rbb #

vec3 get rbb => new vec3(r, b, b);

final vec4 rbbb #

vec4 get rbbb => new vec4(r, b, b, b);

final vec4 rbbg #

vec4 get rbbg => new vec4(r, b, b, g);

final vec4 rbbr #

vec4 get rbbr => new vec4(r, b, b, r);

vec3 rbg #

vec3 get rbg => new vec3(r, b, g);
set rbg(vec3 arg) {
 r = arg.r;
 b = arg.g;
 g = arg.b;
}

final vec4 rbgb #

vec4 get rbgb => new vec4(r, b, g, b);

final vec4 rbgg #

vec4 get rbgg => new vec4(r, b, g, g);

final vec4 rbgr #

vec4 get rbgr => new vec4(r, b, g, r);

final vec3 rbr #

vec3 get rbr => new vec3(r, b, r);

final vec4 rbrb #

vec4 get rbrb => new vec4(r, b, r, b);

final vec4 rbrg #

vec4 get rbrg => new vec4(r, b, r, g);

final vec4 rbrr #

vec4 get rbrr => new vec4(r, b, r, r);

vec2 rg #

vec2 get rg => new vec2(r, g);
set rg(vec2 arg) {
 r = arg.r;
 g = arg.g;
}

vec3 rgb #

vec3 get rgb => new vec3(r, g, b);
set rgb(vec3 arg) {
 r = arg.r;
 g = arg.g;
 b = arg.b;
}

final vec4 rgbb #

vec4 get rgbb => new vec4(r, g, b, b);

final vec4 rgbg #

vec4 get rgbg => new vec4(r, g, b, g);

final vec4 rgbr #

vec4 get rgbr => new vec4(r, g, b, r);

final vec3 rgg #

vec3 get rgg => new vec3(r, g, g);

final vec4 rggb #

vec4 get rggb => new vec4(r, g, g, b);

final vec4 rggg #

vec4 get rggg => new vec4(r, g, g, g);

final vec4 rggr #

vec4 get rggr => new vec4(r, g, g, r);

final vec3 rgr #

vec3 get rgr => new vec3(r, g, r);

final vec4 rgrb #

vec4 get rgrb => new vec4(r, g, r, b);

final vec4 rgrg #

vec4 get rgrg => new vec4(r, g, r, g);

final vec4 rgrr #

vec4 get rgrr => new vec4(r, g, r, r);

final vec2 rr #

vec2 get rr => new vec2(r, r);

final vec3 rrb #

vec3 get rrb => new vec3(r, r, b);

final vec4 rrbb #

vec4 get rrbb => new vec4(r, r, b, b);

final vec4 rrbg #

vec4 get rrbg => new vec4(r, r, b, g);

final vec4 rrbr #

vec4 get rrbr => new vec4(r, r, b, r);

final vec3 rrg #

vec3 get rrg => new vec3(r, r, g);

final vec4 rrgb #

vec4 get rrgb => new vec4(r, r, g, b);

final vec4 rrgg #

vec4 get rrgg => new vec4(r, r, g, g);

final vec4 rrgr #

vec4 get rrgr => new vec4(r, r, g, r);

final vec3 rrr #

vec3 get rrr => new vec3(r, r, r);

final vec4 rrrb #

vec4 get rrrb => new vec4(r, r, r, b);

final vec4 rrrg #

vec4 get rrrg => new vec4(r, r, r, g);

final vec4 rrrr #

vec4 get rrrr => new vec4(r, r, r, r);

double s #

double get s => x;
set s(double arg) => x = arg;

vec2 sp #

vec2 get sp => new vec2(s, p);
set sp(vec2 arg) {
 s = arg.s;
 p = arg.t;
}

final vec3 spp #

vec3 get spp => new vec3(s, p, p);

final vec4 sppp #

vec4 get sppp => new vec4(s, p, p, p);

final vec4 spps #

vec4 get spps => new vec4(s, p, p, s);

final vec4 sppt #

vec4 get sppt => new vec4(s, p, p, t);

final vec3 sps #

vec3 get sps => new vec3(s, p, s);

final vec4 spsp #

vec4 get spsp => new vec4(s, p, s, p);

final vec4 spss #

vec4 get spss => new vec4(s, p, s, s);

final vec4 spst #

vec4 get spst => new vec4(s, p, s, t);

vec3 spt #

vec3 get spt => new vec3(s, p, t);
set spt(vec3 arg) {
 s = arg.s;
 p = arg.t;
 t = arg.p;
}

final vec4 sptp #

vec4 get sptp => new vec4(s, p, t, p);

final vec4 spts #

vec4 get spts => new vec4(s, p, t, s);

final vec4 sptt #

vec4 get sptt => new vec4(s, p, t, t);

final vec2 ss #

vec2 get ss => new vec2(s, s);

final vec3 ssp #

vec3 get ssp => new vec3(s, s, p);

final vec4 sspp #

vec4 get sspp => new vec4(s, s, p, p);

final vec4 ssps #

vec4 get ssps => new vec4(s, s, p, s);

final vec4 sspt #

vec4 get sspt => new vec4(s, s, p, t);

final vec3 sss #

vec3 get sss => new vec3(s, s, s);

final vec4 sssp #

vec4 get sssp => new vec4(s, s, s, p);

final vec4 ssss #

vec4 get ssss => new vec4(s, s, s, s);

final vec4 ssst #

vec4 get ssst => new vec4(s, s, s, t);

final vec3 sst #

vec3 get sst => new vec3(s, s, t);

final vec4 sstp #

vec4 get sstp => new vec4(s, s, t, p);

final vec4 ssts #

vec4 get ssts => new vec4(s, s, t, s);

final vec4 sstt #

vec4 get sstt => new vec4(s, s, t, t);

vec2 st #

vec2 get st => new vec2(s, t);
set st(vec2 arg) {
 s = arg.s;
 t = arg.t;
}

vec3 stp #

vec3 get stp => new vec3(s, t, p);
set stp(vec3 arg) {
 s = arg.s;
 t = arg.t;
 p = arg.p;
}

final vec4 stpp #

vec4 get stpp => new vec4(s, t, p, p);

final vec4 stps #

vec4 get stps => new vec4(s, t, p, s);

final vec4 stpt #

vec4 get stpt => new vec4(s, t, p, t);

final vec3 sts #

vec3 get sts => new vec3(s, t, s);

final vec4 stsp #

vec4 get stsp => new vec4(s, t, s, p);

final vec4 stss #

vec4 get stss => new vec4(s, t, s, s);

final vec4 stst #

vec4 get stst => new vec4(s, t, s, t);

final vec3 stt #

vec3 get stt => new vec3(s, t, t);

final vec4 sttp #

vec4 get sttp => new vec4(s, t, t, p);

final vec4 stts #

vec4 get stts => new vec4(s, t, t, s);

final vec4 sttt #

vec4 get sttt => new vec4(s, t, t, t);

double t #

double get t => y;
set t(double arg) => y = arg;

vec2 tp #

vec2 get tp => new vec2(t, p);
set tp(vec2 arg) {
 t = arg.s;
 p = arg.t;
}

final vec3 tpp #

vec3 get tpp => new vec3(t, p, p);

final vec4 tppp #

vec4 get tppp => new vec4(t, p, p, p);

final vec4 tpps #

vec4 get tpps => new vec4(t, p, p, s);

final vec4 tppt #

vec4 get tppt => new vec4(t, p, p, t);

vec3 tps #

vec3 get tps => new vec3(t, p, s);
set tps(vec3 arg) {
 t = arg.s;
 p = arg.t;
 s = arg.p;
}

final vec4 tpsp #

vec4 get tpsp => new vec4(t, p, s, p);

final vec4 tpss #

vec4 get tpss => new vec4(t, p, s, s);

final vec4 tpst #

vec4 get tpst => new vec4(t, p, s, t);

final vec3 tpt #

vec3 get tpt => new vec3(t, p, t);

final vec4 tptp #

vec4 get tptp => new vec4(t, p, t, p);

final vec4 tpts #

vec4 get tpts => new vec4(t, p, t, s);

final vec4 tptt #

vec4 get tptt => new vec4(t, p, t, t);

vec2 ts #

vec2 get ts => new vec2(t, s);
set ts(vec2 arg) {
 t = arg.s;
 s = arg.t;
}

vec3 tsp #

vec3 get tsp => new vec3(t, s, p);
set tsp(vec3 arg) {
 t = arg.s;
 s = arg.t;
 p = arg.p;
}

final vec4 tspp #

vec4 get tspp => new vec4(t, s, p, p);

final vec4 tsps #

vec4 get tsps => new vec4(t, s, p, s);

final vec4 tspt #

vec4 get tspt => new vec4(t, s, p, t);

final vec3 tss #

vec3 get tss => new vec3(t, s, s);

final vec4 tssp #

vec4 get tssp => new vec4(t, s, s, p);

final vec4 tsss #

vec4 get tsss => new vec4(t, s, s, s);

final vec4 tsst #

vec4 get tsst => new vec4(t, s, s, t);

final vec3 tst #

vec3 get tst => new vec3(t, s, t);

final vec4 tstp #

vec4 get tstp => new vec4(t, s, t, p);

final vec4 tsts #

vec4 get tsts => new vec4(t, s, t, s);

final vec4 tstt #

vec4 get tstt => new vec4(t, s, t, t);

final vec2 tt #

vec2 get tt => new vec2(t, t);

final vec3 ttp #

vec3 get ttp => new vec3(t, t, p);

final vec4 ttpp #

vec4 get ttpp => new vec4(t, t, p, p);

final vec4 ttps #

vec4 get ttps => new vec4(t, t, p, s);

final vec4 ttpt #

vec4 get ttpt => new vec4(t, t, p, t);

final vec3 tts #

vec3 get tts => new vec3(t, t, s);

final vec4 ttsp #

vec4 get ttsp => new vec4(t, t, s, p);

final vec4 ttss #

vec4 get ttss => new vec4(t, t, s, s);

final vec4 ttst #

vec4 get ttst => new vec4(t, t, s, t);

final vec3 ttt #

vec3 get ttt => new vec3(t, t, t);

final vec4 tttp #

vec4 get tttp => new vec4(t, t, t, p);

final vec4 ttts #

vec4 get ttts => new vec4(t, t, t, s);

final vec4 tttt #

vec4 get tttt => new vec4(t, t, t, t);

double x #

x

final vec2 xx #

vec2 get xx => new vec2(x, x);

final vec3 xxx #

vec3 get xxx => new vec3(x, x, x);

final vec4 xxxx #

vec4 get xxxx => new vec4(x, x, x, x);

final vec4 xxxy #

vec4 get xxxy => new vec4(x, x, x, y);

final vec4 xxxz #

vec4 get xxxz => new vec4(x, x, x, z);

final vec3 xxy #

vec3 get xxy => new vec3(x, x, y);

final vec4 xxyx #

vec4 get xxyx => new vec4(x, x, y, x);

final vec4 xxyy #

vec4 get xxyy => new vec4(x, x, y, y);

final vec4 xxyz #

vec4 get xxyz => new vec4(x, x, y, z);

final vec3 xxz #

vec3 get xxz => new vec3(x, x, z);

final vec4 xxzx #

vec4 get xxzx => new vec4(x, x, z, x);

final vec4 xxzy #

vec4 get xxzy => new vec4(x, x, z, y);

final vec4 xxzz #

vec4 get xxzz => new vec4(x, x, z, z);

vec2 xy #

vec2 get xy => new vec2(x, y);
set xy(vec2 arg) {
 x = arg.x;
 y = arg.y;
}

final vec3 xyx #

vec3 get xyx => new vec3(x, y, x);

final vec4 xyxx #

vec4 get xyxx => new vec4(x, y, x, x);

final vec4 xyxy #

vec4 get xyxy => new vec4(x, y, x, y);

final vec4 xyxz #

vec4 get xyxz => new vec4(x, y, x, z);

final vec3 xyy #

vec3 get xyy => new vec3(x, y, y);

final vec4 xyyx #

vec4 get xyyx => new vec4(x, y, y, x);

final vec4 xyyy #

vec4 get xyyy => new vec4(x, y, y, y);

final vec4 xyyz #

vec4 get xyyz => new vec4(x, y, y, z);

vec3 xyz #

vec3 get xyz => new vec3(x, y, z);
set xyz(vec3 arg) {
 x = arg.x;
 y = arg.y;
 z = arg.z;
}

final vec4 xyzx #

vec4 get xyzx => new vec4(x, y, z, x);

final vec4 xyzy #

vec4 get xyzy => new vec4(x, y, z, y);

final vec4 xyzz #

vec4 get xyzz => new vec4(x, y, z, z);

vec2 xz #

vec2 get xz => new vec2(x, z);
set xz(vec2 arg) {
 x = arg.x;
 z = arg.y;
}

final vec3 xzx #

vec3 get xzx => new vec3(x, z, x);

final vec4 xzxx #

vec4 get xzxx => new vec4(x, z, x, x);

final vec4 xzxy #

vec4 get xzxy => new vec4(x, z, x, y);

final vec4 xzxz #

vec4 get xzxz => new vec4(x, z, x, z);

vec3 xzy #

vec3 get xzy => new vec3(x, z, y);
set xzy(vec3 arg) {
 x = arg.x;
 z = arg.y;
 y = arg.z;
}

final vec4 xzyx #

vec4 get xzyx => new vec4(x, z, y, x);

final vec4 xzyy #

vec4 get xzyy => new vec4(x, z, y, y);

final vec4 xzyz #

vec4 get xzyz => new vec4(x, z, y, z);

final vec3 xzz #

vec3 get xzz => new vec3(x, z, z);

final vec4 xzzx #

vec4 get xzzx => new vec4(x, z, z, x);

final vec4 xzzy #

vec4 get xzzy => new vec4(x, z, z, y);

final vec4 xzzz #

vec4 get xzzz => new vec4(x, z, z, z);

double y #

y

vec2 yx #

vec2 get yx => new vec2(y, x);
set yx(vec2 arg) {
 y = arg.x;
 x = arg.y;
}

final vec3 yxx #

vec3 get yxx => new vec3(y, x, x);

final vec4 yxxx #

vec4 get yxxx => new vec4(y, x, x, x);

final vec4 yxxy #

vec4 get yxxy => new vec4(y, x, x, y);

final vec4 yxxz #

vec4 get yxxz => new vec4(y, x, x, z);

final vec3 yxy #

vec3 get yxy => new vec3(y, x, y);

final vec4 yxyx #

vec4 get yxyx => new vec4(y, x, y, x);

final vec4 yxyy #

vec4 get yxyy => new vec4(y, x, y, y);

final vec4 yxyz #

vec4 get yxyz => new vec4(y, x, y, z);

vec3 yxz #

vec3 get yxz => new vec3(y, x, z);
set yxz(vec3 arg) {
 y = arg.x;
 x = arg.y;
 z = arg.z;
}

final vec4 yxzx #

vec4 get yxzx => new vec4(y, x, z, x);

final vec4 yxzy #

vec4 get yxzy => new vec4(y, x, z, y);

final vec4 yxzz #

vec4 get yxzz => new vec4(y, x, z, z);

final vec2 yy #

vec2 get yy => new vec2(y, y);

final vec3 yyx #

vec3 get yyx => new vec3(y, y, x);

final vec4 yyxx #

vec4 get yyxx => new vec4(y, y, x, x);

final vec4 yyxy #

vec4 get yyxy => new vec4(y, y, x, y);

final vec4 yyxz #

vec4 get yyxz => new vec4(y, y, x, z);

final vec3 yyy #

vec3 get yyy => new vec3(y, y, y);

final vec4 yyyx #

vec4 get yyyx => new vec4(y, y, y, x);

final vec4 yyyy #

vec4 get yyyy => new vec4(y, y, y, y);

final vec4 yyyz #

vec4 get yyyz => new vec4(y, y, y, z);

final vec3 yyz #

vec3 get yyz => new vec3(y, y, z);

final vec4 yyzx #

vec4 get yyzx => new vec4(y, y, z, x);

final vec4 yyzy #

vec4 get yyzy => new vec4(y, y, z, y);

final vec4 yyzz #

vec4 get yyzz => new vec4(y, y, z, z);

vec2 yz #

vec2 get yz => new vec2(y, z);
set yz(vec2 arg) {
 y = arg.x;
 z = arg.y;
}

vec3 yzx #

vec3 get yzx => new vec3(y, z, x);
set yzx(vec3 arg) {
 y = arg.x;
 z = arg.y;
 x = arg.z;
}

final vec4 yzxx #

vec4 get yzxx => new vec4(y, z, x, x);

final vec4 yzxy #

vec4 get yzxy => new vec4(y, z, x, y);

final vec4 yzxz #

vec4 get yzxz => new vec4(y, z, x, z);

final vec3 yzy #

vec3 get yzy => new vec3(y, z, y);

final vec4 yzyx #

vec4 get yzyx => new vec4(y, z, y, x);

final vec4 yzyy #

vec4 get yzyy => new vec4(y, z, y, y);

final vec4 yzyz #

vec4 get yzyz => new vec4(y, z, y, z);

final vec3 yzz #

vec3 get yzz => new vec3(y, z, z);

final vec4 yzzx #

vec4 get yzzx => new vec4(y, z, z, x);

final vec4 yzzy #

vec4 get yzzy => new vec4(y, z, z, y);

final vec4 yzzz #

vec4 get yzzz => new vec4(y, z, z, z);

double z #

z

vec2 zx #

vec2 get zx => new vec2(z, x);
set zx(vec2 arg) {
 z = arg.x;
 x = arg.y;
}

final vec3 zxx #

vec3 get zxx => new vec3(z, x, x);

final vec4 zxxx #

vec4 get zxxx => new vec4(z, x, x, x);

final vec4 zxxy #

vec4 get zxxy => new vec4(z, x, x, y);

final vec4 zxxz #

vec4 get zxxz => new vec4(z, x, x, z);

vec3 zxy #

vec3 get zxy => new vec3(z, x, y);
set zxy(vec3 arg) {
 z = arg.x;
 x = arg.y;
 y = arg.z;
}

final vec4 zxyx #

vec4 get zxyx => new vec4(z, x, y, x);

final vec4 zxyy #

vec4 get zxyy => new vec4(z, x, y, y);

final vec4 zxyz #

vec4 get zxyz => new vec4(z, x, y, z);

final vec3 zxz #

vec3 get zxz => new vec3(z, x, z);

final vec4 zxzx #

vec4 get zxzx => new vec4(z, x, z, x);

final vec4 zxzy #

vec4 get zxzy => new vec4(z, x, z, y);

final vec4 zxzz #

vec4 get zxzz => new vec4(z, x, z, z);

vec2 zy #

vec2 get zy => new vec2(z, y);
set zy(vec2 arg) {
 z = arg.x;
 y = arg.y;
}

vec3 zyx #

vec3 get zyx => new vec3(z, y, x);
set zyx(vec3 arg) {
 z = arg.x;
 y = arg.y;
 x = arg.z;
}

final vec4 zyxx #

vec4 get zyxx => new vec4(z, y, x, x);

final vec4 zyxy #

vec4 get zyxy => new vec4(z, y, x, y);

final vec4 zyxz #

vec4 get zyxz => new vec4(z, y, x, z);

final vec3 zyy #

vec3 get zyy => new vec3(z, y, y);

final vec4 zyyx #

vec4 get zyyx => new vec4(z, y, y, x);

final vec4 zyyy #

vec4 get zyyy => new vec4(z, y, y, y);

final vec4 zyyz #

vec4 get zyyz => new vec4(z, y, y, z);

final vec3 zyz #

vec3 get zyz => new vec3(z, y, z);

final vec4 zyzx #

vec4 get zyzx => new vec4(z, y, z, x);

final vec4 zyzy #

vec4 get zyzy => new vec4(z, y, z, y);

final vec4 zyzz #

vec4 get zyzz => new vec4(z, y, z, z);

final vec2 zz #

vec2 get zz => new vec2(z, z);

final vec3 zzx #

vec3 get zzx => new vec3(z, z, x);

final vec4 zzxx #

vec4 get zzxx => new vec4(z, z, x, x);

final vec4 zzxy #

vec4 get zzxy => new vec4(z, z, x, y);

final vec4 zzxz #

vec4 get zzxz => new vec4(z, z, x, z);

final vec3 zzy #

vec3 get zzy => new vec3(z, z, y);

final vec4 zzyx #

vec4 get zzyx => new vec4(z, z, y, x);

final vec4 zzyy #

vec4 get zzyy => new vec4(z, z, y, y);

final vec4 zzyz #

vec4 get zzyz => new vec4(z, z, y, z);

final vec3 zzz #

vec3 get zzz => new vec3(z, z, z);

final vec4 zzzx #

vec4 get zzzx => new vec4(z, z, z, x);

final vec4 zzzy #

vec4 get zzzy => new vec4(z, z, z, y);

final vec4 zzzz #

vec4 get zzzz => new vec4(z, z, z, z);

Operators

double operator [](int i) #

Returns a component from vec3. This is indexed as an array with i

double operator[](int i) {
 assert(i >= 0 && i < 3);
 switch (i) {
   case 0: return x;
   case 1: return y;
   case 2: return z;
 };
 return 0.0;
}

void operator []=(int i, double v) #

Assigns a component in vec3 the value in v. This is indexed as an array with i

void operator[]=(int i, double v) {
 assert(i >= 0 && i < 3);
 switch (i) {
   case 0: x = v; break;
   case 1: y = v; break;
   case 2: z = v; break;
 };
}

vec3 operator +(vec3 other) #

Returns a new vec3 from this + other

vec3 operator+(vec3 other) => new vec3.raw(x + other.x, y + other.y, z + other.z);

vec3 operator -() #

Returns a new vec3 from -this

vec3 operator-() => new vec3.raw(-x, -y, -z);

vec3 operator -(vec3 other) #

Returns a new vec3 from this - other

vec3 operator-(vec3 other) => new vec3.raw(x - other.x, y - other.y, z - other.z);

vec3 operator *(other) #

Returns a new vec3 scaled by other

vec3 operator*(dynamic other) {
 if (other is num) {
   var o = other.toDouble();
   return new vec3.raw(x * o, y * o, z * o);
 }
 if (other is vec3) {
   return new vec3.raw(x * other.x, y * other.y, z * other.z);
 }
}

vec3 operator /(other) #

Returns a new vec3 divided by other

vec3 operator/(dynamic other) {
 if (other is num) {
   var o = 1.0 / other.toDouble();
   return new vec3.raw(x * o, y * o, z * o);
 }
 if (other is vec3) {
   return new vec3.raw(x / other.x, y / other.y, z / other.z);
 }
}

Methods

vec3 absolute() #

vec3 absolute() {
 x = x.abs();
 y = y.abs();
 z = z.abs();
 return this;
}

double absoluteError(vec3 correct) #

Returns the absolute error between this and correct

double absoluteError(vec3 correct) {
 return (this - correct).length;
}

vec3 add(vec3 arg) #

vec3 add(vec3 arg) {
 x = x + arg.x;
 y = y + arg.y;
 z = z + arg.z;
 return this;
}

vec3 clone() #

vec3 clone() {
 return new vec3.copy(this);
}

vec3 copyFrom(vec3 arg) #

vec3 copyFrom(vec3 arg) {
 x = arg.x;
 y = arg.y;
 z = arg.z;
 return this;
}

void copyFromArray(List<num> array, [int offset = 0]) #

Copies elements from array into this starting at offset.

void copyFromArray(List<num> array, [int offset=0]) {
 int i = offset;
 x = array[i].toDouble();
 i++;
 y = array[i].toDouble();
 i++;
 z = array[i].toDouble();
 i++;
}

vec3 copyInto(vec3 arg) #

vec3 copyInto(vec3 arg) {
 arg.x = x;
 arg.y = y;
 arg.z = z;
 return arg;
}

void copyIntoArray(List<num> array, [int offset = 0]) #

Copies this into array starting at offset.

void copyIntoArray(List<num> array, [int offset=0]) {
 int i = offset;
 array[i] = x;
 i++;
 array[i] = y;
 i++;
 array[i] = z;
 i++;
}

vec3 cross(vec3 other, [vec3 out = null]) #

Returns the cross product of this and other, optionally pass in output storage out

vec3 cross(vec3 other, [vec3 out=null]) {
 if (out == null) {
   out = new vec3.zero();
 }
 out.x = y * other.z - z * other.y;
 out.y = z * other.x - x * other.z;
 out.z = x * other.y - y * other.x;
 return out;
}

vec3 div(vec3 arg) #

vec3 div(vec3 arg) {
 x = x / arg.x;
 y = y / arg.y;
 z = z / arg.z;
 return this;
}

double dot(vec3 other) #

Returns the dot product of this and other

double dot(vec3 other) {
 double sum = 0.0;
 sum += (x * other.x);
 sum += (y * other.y);
 sum += (z * other.z);
 return sum;
}

vec3 makeCopy(vec3 other) #

Make this a copy of [other] [other].

vec3 makeCopy(vec3 other) {
 x = other.x;
 y = other.y;
 z = other.z;
 return this;
}

vec3 makeRaw(num x_, num y_, num z_) #

Components of this are set to the passed in values.

vec3 makeRaw(num x_, num y_, num z_) {
 x = x_.toDouble();
 y = y_.toDouble();
 z = z_.toDouble();
 return this;
}

vec3 makeZero() #

Make this the zero vector.

vec3 makeZero() {
 x = 0.0;
 y = 0.0;
 z = 0.0;
 return this;
}

vec3 multiply(vec3 arg) #

vec3 multiply(vec3 arg) {
 x = x * arg.x;
 y = y * arg.y;
 z = z * arg.z;
 return this;
}

vec3 negate() #

vec3 negate() {
 x = -x;
 y = -y;
 z = -z;
 return this;
}

vec3 normalize() #

Normalizes this. Returns this.

vec3 normalize() {
 double l = length;
 if (l == 0.0) {
   return this;
 }
 x /= l;
 y /= l;
 z /= l;
 return this;
}

vec3 normalized([vec3 out = null]) #

Normalizes this returns new vector or optional out

vec3 normalized([vec3 out = null]) {
 if (out == null) {
   out = new vec3.raw(x, y, z);
 }
 double l = out.length;
 if (l == 0.0) {
   return out;
 }
 out.x /= l;
 out.y /= l;
 out.z /= l;
 return out;
}

double normalizeLength() #

Normalizes this. Returns length.

double normalizeLength() {
 double l = length;
 if (l == 0.0) {
   return 0.0;
 }
 x /= l;
 y /= l;
 z /= l;
 return l;
}

double relativeError(vec3 correct) #

Returns the relative error between this and correct

double relativeError(vec3 correct) {
 double correct_norm = correct.length;
 double diff_norm = (this - correct).length;
 return diff_norm/correct_norm;
}

vec3 scale(num arg) #

vec3 scale(num arg) {
 double a = arg.toDouble();
 x = x * a;
 y = y * a;
 z = z * a;
 return this;
}

vec3 scaled(num arg) #

vec3 scaled(num arg) {
 return clone().scale(arg);
}

vec3 set(vec3 arg) #

vec3 set(vec3 arg) {
 x = arg.x;
 y = arg.y;
 z = arg.z;
 return this;
}

vec3 setComponents(num x_, num y_, num z_) #

vec3 setComponents(num x_, num y_, num z_) {
 x = x_.toDouble();
 y = y_.toDouble();
 z = z_.toDouble();
 return this;
}

vec3 splat(num arg) #

Splats a scalar into all lanes of the vector.

vec3 splat(num arg) {
 double a = arg.toDouble();
 x = a;
 y = a;
 z = a;
 return this;
}

vec3 sub(vec3 arg) #

vec3 sub(vec3 arg) {
 x = x - arg.x;
 y = y - arg.y;
 z = z - arg.z;
 return this;
}

String toString() #

Returns a printable string

String toString() => '$x,$y,$z';