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


PgAccess on Win32
In order to run PgAccess on a Win32 workstation you should follow the
following steps:
-
download and install a Tcl/Tk package from Scriptics
(8.0.x or 8.1.x)
-
install PgAccess package
-
check the Tcl/Tk version that you have
-
check the PostgreSQL version installed on your database server machine
-
get from win32/dll directory the appropriate libraries suitable for your
Tcl/Tk version and PostgreSQL version and copy them into your Windows/System
directory renaming them as libpq.dll and libpgtcl.dll
-
check if your win32 workstation is able to see your database server (ping
yourdatabaseserver)
-
ask your database administrator to verify if your win32 workstation has
access rights to the database (pg_hba.conf)
You should be able to run PgAccess.


This is called Poem Problem!! The Spaces and Line breaks don't matter in p tag.
Thus, We use the pre tag which stands for "pre-formatted text" which displays our messages in exact manner as we write in HTML source files!
These are displayed in fixed font (usually Courier) and size.
Let It! Look in my eyes! What do you see? => The cult of personality $$$ Like Joseph Stallin... And Gandhi.... I am the Cult of personality


---
layout: js-documentation
title: Ink.UI.Droppable_1
description: Drop elements around
site_root: ../
---
All samples are using Makes an element droppable. The onHover, onDrop, and onDropOut options below can be:Ink.requireModules
, please read how to use it at Ink.requireModules section
Ink.UI.Droppable namespace
Function name
Description
.add(element, [options])
Makes an element droppable.
.remove(el)
Removes an element from the droppable stack and removes the droppable behavior
.update(element)
Updates location and size of droppable element
.add(element, [options])
method
This method adds it to the stack of droppable elements.
Can consider it a constructor of droppable elements, but where no Droppable object is returned.
element
Target elementoptions
Options objectoptions.hoverClass
Classname(s) applied when an acceptable draggable element is hovering the elementoptions.accept
Selector for choosing draggables which can be dropped in this droppable.options.onHover
Called when an acceptable element is hovering the droppable (see above for string options).options.onDrop
Called when an acceptable element is dropped (see above for string options).options.onDropOut
Called when a droppable is dropped outside this droppable (see above for string options).Removes an element from the droppable stack and removes the droppable behavior
el
Droppable element to disable.Updates location and size of droppable element
element
Target element


A band must not contain more than 7 members.
> Every band will get 10 minutes for setup and 20 minutes to play.
> Rating will be done on the basis of Synchronization, Song Selection, music and overall performance.
> Every band must bring its own instruments except the drum kit.It will be provided.
> Any kind of music like fusion, metal and rock etc. are allowed.
> Vulgarity in any way shall not be entertained. It may lead to disqualification of the band.
> Decision of the Judges will be the final decision.
> There will be 2 to 3 finalists who will be performing on the final day after screening.
> Only individual Participation is allowed.
> Duration of the song shall be 3-4 minutes.
> Use of obscene words in tracks is strictly prohibited.
> Judgment will be based on selection of instrument, voice quality, song selection & overall impression.
> Participants are required to face auditions before the event.
> Two or more not more than Four Participation is allowed.
> Duration of the song shall be 5-6 minutes.
> Use of obscene words in tracks is strictly prohibited.
> Judgment will be based on selection of instrument, voice quality, song selection & overall impression.
> Participants are required to face auditions before the event.
> Individual Participation is allowed.
> Time limit is 3 to 5 mins.
> Rating will be done on the basis of dance quality, costumes, expression & music.
> Use of obscene words in tracks or vulgar steps is prohibited.
> A team of 5-12 members will be allowed.
> Time limit is 5-8 Minutes.
> Rating will be done on the basis of dance step, costume, expression, synchronization & music.
> Lighting of candles, matches on the stage is not allowed and this will lead to disqualification.
> Use of obscene words in tracks or vulgar steps is prohibited.
> Individual participation is allowed.
> A Preliminary round will be held first before the on-stage round.
> On-stage round will consist of 2 sub-rounds, i.e.,
(i). Personality round
(ii). Talent Hunt round
> A team of 5 to 10 members will be allowed.
> The duration of the skit should be 8-10 minutes.
> The theme, dialogues and presentation of the skit should not be vulgar and objectionable.
> Usable props are allowed. All the required props should be arranged by the participating team only.
> All the costumes will be arranged by the participating teams themselves.
> Rating will be given on the basis of performance, co-ordination, costume, quality of dialogues.
> Solo participation will be there.
> Participants can present their poetry on any theme.
> Simple reading of lines from paper is not allowed.
> Time duration: 3 to 4 minutes.
> Use of obscene words in is prohibited.
> Both Individual and Team participation is allowed
(A team of 5 to 10 members will be allowed).
> Time duration is 4-8 minuts.
> The performance should not be vulgar or objectionable.
> Paper reading is not allowed.
> Judgment will be done on the basis of: Content, Humor, Presentation etc.
> Maximum team size is 15 including backstage/technical crew.
> Clothing or actions that could be perceived as obscene, lewd, vulgar or plainly offensive is strictly prohibited.
> No costumes will be provided by us
> In case of any situations which have not been described in the rules, the decision taken by the judges will be final.
> Language can be Hindi/English. Regional touch can be given.
> No music or electronic equipment (including microphones) are allowed.
> Exceeding time limit will attract a penalty of marks.
> Decision of judges will be final and non-disputable.
> Any adaptation from some original piece of work should be mentioned with the script.
> Maximum of 2 members per team are allowed.
> A preliminary round will be conducted first to shortlist teams.
> The decisions of the quizmaster shall be final and binding.
> Each team must consist of 2 members.
> The language of the songs will be Hindi.
> Only 6 teams will be selected from the preliminary round for the final on stage event.
> Participants must have fair idea of particulars of popular songs.
> Some of the rounds will hold negative marking & relative marking in accordance with the quality of the question to be asked.
> Participants can take part in these sub-events -:
i. Dubmash
ii. Prank videos
iii. Short films.
> Movie can have a max size of 4-5 minutes.
> An offensive or vulgar submission will be disqualified directly.
> Team of 4 members.
> Make a Live advertisement on given product.
> Students are invited to bring ideas for their canopies.
> Best six ideas will be selected for the canopy games section.
> The college itself will provide the canopy setup.


Elementh is a blockchain designed for the e-commerce sector. It represents a register of "ownership of goods", which has the ability to write specialized smart contracts and use the nomenclature standard to quickly create various decentralized and centralized applications.


Thank you for using formhub! If you need any extra help or have questions about the service below please consider one of the support options below:


How artificial intelligence and robots create new risks and opportunities for insurance and society
As the world becomes increasingly automated, it is forcing underwriters to adapt and navigate a new risk environment. Meanwhile insurers are leveraging the potential of AI themselves to remain competitive, improve processes and increase efficiency. Lloyd’s have commissioned two reports in collaboration with the University of Surrey that explore these trends in more detail.
“Taking control: artificial intelligence and insurance” analyses the associated risks of AI implementation as well as the potential for AI to help insurers improve their operations and develop new products. Building on this, “Taking control: robots and risk” investigates the impact “collaborative robots” (or cobots) on the economy, and the subsequent risks implications for the insurance industry.
This report identifies four risks areas for AI: trust and transparency, ethics, security and safety. It highlights that as artificial intelligence systems become more complex, cyber breaches are likely to have an even greater impact. The report also explores new business opportunities for insurers from developing new products for companies using the AI to applying the technology to improve insurance processes and deliver better value.
In the future millions of jobs could be taken over by increasingly sophisticated robots or cobots (“collaborative robots”), according to various predictions. This report explores robotics potential to significantly change the risk landscape in many parts of the economy, including: manufacturing, agriculture, healthcare and retail. It also explores the opportunity for insurers to collaborate with clients as data from cobots will provide a much greater understanding of risk and offer opportunities for improved risks and pricing models.


CrimPapers
Articles published on 18 May 2018
On 18 May 2018, 10 new articles were published in 10 journals.
Performance-Based Evaluation, State Compensation and Judicial Ecology: Dynamics of China’s Detention Review Practice
How Collective Is Collective Efficacy? the Importance of Consensus in Judgments About Community Cohesion and Willingness to Intervene by Ianbrunton‐smith
,
patricksturgis
,
georgeleckie
Sometimes They Mean What They Say: Understanding Violence Among Domestic Extremists by Victor Asal, Andrew Vitek
Bruised and Battered: Reinforcing Intimate Partner Violence in Comic Books by Tammy S. Garland, Christina Policastro, Kathryn A. Branch, Brandy B. Henderson
Deconstructing the Lesbian, Gay, Bisexual, Transgender Victim of Sex Trafficking: Harm, Exceptionality and Religion–sexuality Tensions by Avi Boukli, Flora Renz
We Used to Live on Our Own Little Islands: A Qualitative Evaluation of Multifamily Therapy With Veterans by Elisa van Ee, Sophia Murris, Daniël Kool
Outcry Consistency and Prosecutorial Decisions in Child Sexual Abuse Cases by Tammy E. Bracewell
Depression and Anxiety Outcomes of Offending Trajectories: A Systematic Review of Prospective Longitudinal Studies
Parent–child Relations and Delinquency Among African American and European American Juvenile Offenders: An Expanded Examination of Self-Control Theory by Rebecca L. Fix, Janice E. Clifford, Barry R. Burkhart
Sex Offender Supervision: Communication, Training, and Mutual Respect Are Necessary For Effective Collaboration Between Probation Officers and Therapists by Nicholas P. Newstrom, Michael Miner, Chris Hoefer, R. Karl Hanson, Beatrice “Bean” E. Robinson


There are probably a lot of metaphors and symbolism that I just flat out missed when I saw Chinese Box. It could have something to do with seeing it at 9:00 AM with only 3 hours sleep, or it could just be the subject matter which I am admittedly not an expert on.
The film is set in Hong Kong during the days between New Year's Eve 1996 (the last under British control) and July 1, 1997 (when China reclaimed the province). Sounds exciting so far, right? Throw in a tiresome romance that goes ultimately unresolved and you've got yourself two hours of pure unadulterated fun.
Jeremy Irons plays John, a sickly Brit author transplanted in Hong Kong for the last fifteen years. He's left his wife and kid back home, presumably to pursue the love of his life, Vivian (Gong Li, Farewell My Concubine). Vivian, a former hooker and John's ex, owns a successful karaoke bar but wants only to marry her wealthy politician boyfriend, Chang (Michael Hui), in order to distance herself from a dirty slutty past. The trouble is that there is absolutely no emotional spark between John and Vivian, and that is a fact that made me very sleepy.
The saving grace of Chinese Box comes from Maggie Cheung (Supercop), who plays a street-wise con artist named Jean. John meets her while filming a monotonous video diary of how the impending hand-over will effect citizens of different social pedigree. Jumpy Jean immediately intrigues John, who squanders his days away trying to find out what makes her tick.
What these two stories have to do with each other is beyond me. I guess that I understand the basic comparison of the uncertainty of the three main characters with the real life inhabitants of the province, but that's a pretty weak plot. Perhaps viewers more intimate with the subject matter may find it more passionate.
I'm not even sure if director Wayne Wang found that passion in his finished product. Wang's previous efforts seem much more emotional to me, especially The Joy Luck Club and, one of my secret guilty pleasures, Slamdance. Don't laugh.
And what's the deal with Jeremy Irons career?  Gong Li, who is widely regarded as the most beautiful woman on the planet, is under used in her first English speaking role. Her lines are limited and usually monosyllabic. And it is very strange to see her wearing blue jeans. Cheung and Ruben Blades (The Devil's Own) shine in their supporting roles.
To summarize, Chinese Box was about as exciting as the actual Hong Kong hand-over. It was a lot more efficient as a three-minute sound bite delivered by Peter Jennings.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Shapes (Some shapes use the CSS clip-path candidate specification and the SVG element, and will not work in Internet Explorer
- the webui.js javascript file is required for these shapes. Pointers, arrows, and razor-blade styles do not use this
technique, are cross browser compatible, and do not require javascript.)
Shapes using transforms (Cross browser)
Custom shapes using transforms with transform modifier data (Cross browser)
Shapes using clip-path (Not supported by Internet Explorer)
Custom shapes using clip-path with path data (Not supported by Internet Explorer)


abstract class LayerBase : Layer, OptionsCapsule
<init> |
LayerBase(mapping: Options, data: Any? = null, geom: GeomOptions, stat: StatOptions, position: PosOptions, show_legend: Boolean, sampling: Any? = null) |
parameters |
open val parameters: Options
|
toSpec |
fun Layer.toSpec(): MutableMap<String, Any> |
geom_abline |
Add straight lines to a plot specified by slope and intercept. class geom_abline : ABLineAesthetics, LayerBase |
geom_area |
Display an area. class geom_area : AreaAesthetics, LayerBase |
geom_bar |
Bar chart which makes the height of the bar proportional to the number of observed variable values, mapped to x axis. class geom_bar : BarAesthetics, LayerBase |
geom_boxplot |
Add box plot. class geom_boxplot : BoxplotAesthetics, BoxplotParameters, LayerBase |
geom_density |
Display density function. class geom_density : DensityAesthetics, LayerBase |
geom_histogram |
Displays a 1d distribution by dividing variable mapped to x axis into bins and counting the number of observations in each bin. class geom_histogram : HistogramAesthetics, BinAesthetics, LayerBase |
geom_hline |
Add straight horizontal lines to a plot class geom_hline : HLineAesthetics, LayerBase |
geom_line |
Connect points in order of the variable on the x-axis class geom_line : LineAesthetics, LayerBase |
geom_path |
Connects observations in the order, how they appear in the data. class geom_path : PathAesthetics, LayerBase |
geom_point |
Points, as for a scatter plot. class geom_point : PointAesthetics, LayerBase |
geom_raster |
Rectangles with x, y values mapped to center. Much faster than geom_tile but doesn't support width/height and color. class geom_raster : RasterAesthetics, LayerBase |
geom_rect |
Draws rectangles class geom_rect : RectAesthetics, LayerBase |
geom_segment |
Draws segments class geom_segment : SegmentAesthetics, LayerBase |
geom_text |
Adds text directly to the plot class geom_text : TextAesthetics, LayerBase |
geom_tile |
Rectangles with x, y values mapped to center class geom_tile : TileAesthetics, LayerBase |
geom_vline |
Add straight horizontal lines to a plot class geom_vline : VLineAesthetics, LayerBase |
stat_boxplot |
class stat_boxplot : BoxplotAesthetics, BoxplotParameters, LayerBase |
stat_count |
class stat_count : CountAesthetics, BarAesthetics, CountParameters, LayerBase |
stat_density |
class stat_density : DensityAesthetics, DensityParameters, LayerBase |


You can learn JavaScript without HTML & CSS, but for DOM manipulation it's useful to have some basic ideas of HTML & CSS. You can see more on my GitHub: Jesse on GitHub
Just another paragraph
Please fill in this form


Before Change
if not os.path.isfile(job_id_file):
continue
with open(job_id_file) as job:
job_id = job.read().strip()
try:
cmd = interpolate(self.kill_cmd, "${ }", {"task": task_id, "job_id": job_id})
res += self.agent.check_output(cmd) + "\n"
except Exception as e:
After Change
if not job_id:
continue
try:
job_id.update({"task": task_id})
cmd = interpolate(self.kill_cmd, "${ }", job_id)
res += self.agent.check_output(cmd) + "\n"
except Exception as e:
env.logger.debug("Failed to kill job {} (job_id: {}) from template "{}": {}".format(


Wanderlust TourGuidr
Our app is designed to help you on your journey exploring the world! The idea was to be able to visit famous places and get a whole automated intelligent tour of the sites you visit. That way, you won't ever get bored and you'll get an interesting history lesson on the significance of the sites you visit.
Mainly a web service for our Android app, you can take a look at tour guide image search and world heritage sites image search.


Create TABLE
While the above is editable, please be careful as the field names above are used in the catalog, and if they don't match it could be an issue.
Schema (PostgreSQL syntax -- for BigDAWG catalog)
While the above is editable, please be careful as the field names above are used in the catalog, and if they don't match it could be an issue.


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| angular-form-gen/ | 79.03% | 49/62 | 64.29% | 18/28 | 88.89% | 16/18 | 79.03% | 49/62 | |
| angular-form-gen/common/ | 78.72% | 37/47 | 57.14% | 8/14 | 69.23% | 9/13 | 80.43% | 37/46 | |
| angular-form-gen/common/jsonify/ | 33.33% | 3/9 | 0% | 0/6 | 40% | 2/5 | 33.33% | 3/9 | |
| angular-form-gen/common/tabs/ | 92.86% | 26/28 | 87.5% | 14/16 | 100% | 4/4 | 92.86% | 26/28 | |
| angular-form-gen/drag/ | 31.37% | 32/102 | 5.17% | 3/58 | 26.67% | 8/30 | 32% | 32/100 | |
| angular-form-gen/edit/ | 100% | 1/1 | 100% | 0/0 | 100% | 1/1 | 100% | 1/1 | |
| angular-form-gen/edit/canvas/ | 29.03% | 9/31 | 0% | 0/8 | 10% | 1/10 | 29.03% | 9/31 | |
| angular-form-gen/edit/canvas/field/properties/options/ | 5.41% | 2/37 | 0% | 0/32 | 0% | 0/8 | 5.41% | 2/37 | |
| angular-form-gen/edit/palette/ | 100% | 11/11 | 100% | 6/6 | 100% | 2/2 | 100% | 11/11 | |
| angular-form-gen/edit/palette/categories/ | 100% | 9/9 | 100% | 2/2 | 100% | 2/2 | 100% | 9/9 | |
| angular-form-gen/form/ | 90% | 18/20 | 66.67% | 4/6 | 100% | 5/5 | 90% | 18/20 | |
| angular-form-gen/form/field/ | 100% | 44/44 | 100% | 17/17 | 100% | 12/12 | 100% | 44/44 | |
| angular-form-gen/form/schema/ | 100% | 24/24 | 100% | 19/19 | 100% | 6/6 | 100% | 23/23 |


Create a default input by adding the classes .input, .is-default
to an input
element. You can also make its edges rounded by adding the class .is-rounded
.
Use validation inputs markup and toggle the .has-success, .has-warning, .has-error
validation classes on the .control
parent element to change the input states.
Change an input state to loadin by adding the .is-loading
class to the .control
wrapper element.
Disable an input by adding the attribute disabled
to it.
Make an input readonly by adding the attribute readonly
to it.
You can build more complex variations using the .has-addon
modifier on .control
elements. Here are some examples you can copy and adapt to your needs.
Nephos ships with its own html5 select
box. You won't need to use any kind of plugin if you don't want to. Selects have a few customization options like adding an icon or a loading indicator. Check the Html markup
for more details about the code.
Chosen select boxes offer even more flexibility than native selects. They are optimized for huge options list and display a search field when there are 6 ore more options.
Nephos comes with several autocomplete examples powered by the easyAutocomplete
plugin. Refer to the template Documentation
for more details about usage.
easyAutocomplete
lets you create more complex examples with custom templating. Check the existing examples and refer to the template Documentation
for more details about usage.
Nephos ships with a spinner input component based on the spinnerjs
library initially for Bootstrap 4
but adapted for Bulma
. The plugin supports native input attributes such as value
, min
, max
and step
.
Nephos ships with a lightweight and simple to use datepicker. You can initialize it on a simple text input
. Refer to the template Documentation
for more details about usage.
A simple product card featuring card and wishlist interations, as well as a possibility to zoom the image by clicking on it, achieved with the zoomjs
plugin.
A streched variation of the product card, ideal for displaying featured products.
Small cards with a fancy look that can be used to display small amounts of information, like the achievement example.
A basic user profile card that you can extend to suit your needs, depending on your requirements.


Welcome to the...
Firebase
Auth
Sign
Create User
Log in with GitHub
Log in with Facebook
Log in with Twitter
Log in with Google