| // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| patch class Float32x4 { |
| /* patch */ factory Float32x4(double x, double y, double z, double w) { |
| return new _Float32x4(x, y, z, w); |
| } |
| /* patch */ factory Float32x4.zero() { |
| return new _Float32x4.zero(); |
| } |
| } |
| |
| patch class Uint32x4 { |
| /* patch */ factory Uint32x4(int x, int y, int z, int w) { |
| return new _Uint32x4(x, y, z, w); |
| } |
| /* patch */ factory Uint32x4.bool(bool x, bool y, bool z, bool w) { |
| return new _Uint32x4.bool(x, y, z, w); |
| } |
| } |
| |
| |
| patch class Float32x4List { |
| /* patch */ factory Float32x4List(int length) { |
| return new _Float32x4Array(length); |
| } |
| |
| /* patch */ factory Float32x4List.transferable(int length) { |
| return _newTransferable(length); |
| } |
| |
| /* patch */ factory Float32x4List.view(ByteArray array, |
| [int start = 0, int length]) { |
| return new _Float32x4ArrayView(array, start, length); |
| } |
| |
| static _ExternalFloat32x4Array _newTransferable(int length) |
| native "Float32x4List_newTransferable"; |
| } |
| |
| |
| // Expose native square root. |
| double _sqrt(double x) native "Math_sqrt"; |
| class _Float32x4Dart implements Float32x4 { |
| final Float32List _storage = new Float32List(4); |
| _Float32x4Dart.empty() { |
| } |
| _Float32x4Dart.copy(Float32List other) { |
| _storage[0] = other._storage[0]; |
| _storage[1] = other._storage[1]; |
| _storage[2] = other._storage[2]; |
| _storage[3] = other._storage[3]; |
| } |
| factory _Float32x4Dart(double x, double y, double z, double w) { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = x; |
| instance._storage[1] = y; |
| instance._storage[2] = z; |
| instance._storage[3] = w; |
| return instance; |
| } |
| factory _Float32x4Dart.zero() { |
| var instance = new _Float32x4Dart.empty(); |
| return instance; |
| } |
| Float32x4 operator +(Float32x4 other) { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[0] + other._storage[0]; |
| instance._storage[1] = _storage[1] + other._storage[1]; |
| instance._storage[2] = _storage[2] + other._storage[2]; |
| instance._storage[3] = _storage[3] + other._storage[3]; |
| return instance; |
| } |
| Float32x4 operator -() { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = -_storage[0]; |
| instance._storage[1] = -_storage[1]; |
| instance._storage[2] = -_storage[2]; |
| instance._storage[3] = -_storage[3]; |
| return instance; |
| } |
| Float32x4 operator -(Float32x4 other) { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[0] - other._storage[0]; |
| instance._storage[1] = _storage[1] - other._storage[1]; |
| instance._storage[2] = _storage[2] - other._storage[2]; |
| instance._storage[3] = _storage[3] - other._storage[3]; |
| return instance; |
| } |
| Float32x4 operator *(Float32x4 other) { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[0] * other._storage[0]; |
| instance._storage[1] = _storage[1] * other._storage[1]; |
| instance._storage[2] = _storage[2] * other._storage[2]; |
| instance._storage[3] = _storage[3] * other._storage[3]; |
| return instance; |
| } |
| Float32x4 operator /(Float32x4 other) { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[0] / other._storage[0]; |
| instance._storage[1] = _storage[1] / other._storage[1]; |
| instance._storage[2] = _storage[2] / other._storage[2]; |
| instance._storage[3] = _storage[3] / other._storage[3]; |
| return instance; |
| } |
| Uint32x4 lessThan(Float32x4 other) { |
| bool _x = _storage[0] < other._storage[0]; |
| bool _y = _storage[1] < other._storage[1]; |
| bool _z = _storage[2] < other._storage[2]; |
| bool _w = _storage[3] < other._storage[3]; |
| return new Uint32x4.bool(_x, _y, _z, _w); |
| } |
| Uint32x4 lessThanOrEqual(Float32x4 other) { |
| bool _x = _storage[0] <= other._storage[0]; |
| bool _y = _storage[1] <= other._storage[1]; |
| bool _z = _storage[2] <= other._storage[2]; |
| bool _w = _storage[3] <= other._storage[3]; |
| return new Uint32x4.bool(_x, _y, _z, _w); |
| } |
| Uint32x4 greaterThan(Float32x4 other) { |
| bool _x = _storage[0] > other._storage[0]; |
| bool _y = _storage[1] > other._storage[1]; |
| bool _z = _storage[2] > other._storage[2]; |
| bool _w = _storage[3] > other._storage[3]; |
| return new Uint32x4.bool(_x, _y, _z, _w); |
| } |
| Uint32x4 greaterThanOrEqual(Float32x4 other) { |
| bool _x = _storage[0] >= other._storage[0]; |
| bool _y = _storage[1] >= other._storage[1]; |
| bool _z = _storage[2] >= other._storage[2]; |
| bool _w = _storage[3] >= other._storage[3]; |
| return new Uint32x4.bool(_x, _y, _z, _w); |
| } |
| Uint32x4 equal(Float32x4 other) { |
| bool _x = _storage[0] == other._storage[0]; |
| bool _y = _storage[1] == other._storage[1]; |
| bool _z = _storage[2] == other._storage[2]; |
| bool _w = _storage[3] == other._storage[3]; |
| return new Uint32x4.bool(_x, _y, _z, _w); |
| } |
| Uint32x4 notEqual(Float32x4 other) { |
| bool _x = _storage[0] != other._storage[0]; |
| bool _y = _storage[1] != other._storage[1]; |
| bool _z = _storage[2] != other._storage[2]; |
| bool _w = _storage[3] != other._storage[3]; |
| return new Uint32x4.bool(_x, _y, _z, _w); |
| } |
| Float32x4 scale(double s) { |
| var instance = new _Float32x4Dart.copy(this); |
| instance._storage[0] *= s; |
| instance._storage[1] *= s; |
| instance._storage[2] *= s; |
| instance._storage[3] *= s; |
| return instance; |
| } |
| Float32x4 abs() { |
| var instance = new _Float32x4Dart.copy(this); |
| instance._storage[0] = instance._storage[0].abs(); |
| instance._storage[1] = instance._storage[1].abs(); |
| instance._storage[2] = instance._storage[2].abs(); |
| instance._storage[3] = instance._storage[3].abs(); |
| return instance; |
| } |
| Float32x4 clamp(Float32x4 lowerLimit, |
| Float32x4 upperLimit) { |
| var instance = new _Float32x4Dart.copy(this); |
| if (instance._storage[0] > upperLimit._storage[0]) { |
| instance._storage[0] = upperLimit._storage[0]; |
| } |
| if (instance._storage[1] > upperLimit._storage[1]) { |
| instance._storage[1] = upperLimit._storage[1]; |
| } |
| if (instance._storage[2] > upperLimit._storage[2]) { |
| instance._storage[2] = upperLimit._storage[2]; |
| } |
| if (instance._storage[3] > upperLimit._storage[3]) { |
| instance._storage[3] = upperLimit._storage[3]; |
| } |
| if (instance._storage[0] < lowerLimit._storage[0]) { |
| instance._storage[0] = lowerLimit._storage[0]; |
| } |
| if (instance._storage[1] < lowerLimit._storage[1]) { |
| instance._storage[1] = lowerLimit._storage[1]; |
| } |
| if (instance._storage[2] < lowerLimit._storage[2]) { |
| instance._storage[2] = lowerLimit._storage[2]; |
| } |
| if (instance._storage[3] < lowerLimit._storage[3]) { |
| instance._storage[3] = lowerLimit._storage[3]; |
| } |
| return instance; |
| } |
| double get x => _storage[0]; |
| double get y => _storage[1]; |
| double get z => _storage[2]; |
| double get w => _storage[3]; |
| Float32x4 get xxxx { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[0]; |
| instance._storage[1] = _storage[0]; |
| instance._storage[2] = _storage[0]; |
| instance._storage[3] = _storage[0]; |
| return instance; |
| } |
| Float32x4 get yyyy { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[1]; |
| instance._storage[1] = _storage[1]; |
| instance._storage[2] = _storage[1]; |
| instance._storage[3] = _storage[1]; |
| return instance; |
| } |
| Float32x4 get zzzz { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[2]; |
| instance._storage[1] = _storage[2]; |
| instance._storage[2] = _storage[2]; |
| instance._storage[3] = _storage[2]; |
| return instance; |
| } |
| Float32x4 get wwww { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _storage[3]; |
| instance._storage[1] = _storage[3]; |
| instance._storage[2] = _storage[3]; |
| instance._storage[3] = _storage[3]; |
| return instance; |
| } |
| Float32x4 withX(double x) { |
| var instance = new _Float32x4Dart.copy(this); |
| instance._storage[0] = x; |
| return instance; |
| } |
| Float32x4 withY(double y) { |
| var instance = new _Float32x4Dart.copy(this); |
| instance._storage[1] = y; |
| return instance; |
| } |
| Float32x4 withZ(double z) { |
| var instance = new _Float32x4Dart.copy(this); |
| instance._storage[2] = z; |
| return instance; |
| } |
| Float32x4 withW(double w) { |
| var instance = new _Float32x4Dart.copy(this); |
| instance._storage[3] = w; |
| return instance; |
| } |
| Float32x4 min(Float32x4 other) { |
| var instance = new _Float32x4Dart.copy(this); |
| if (instance._storage[0] > other._storage[0]) { |
| instance._storage[0] = other._storage[0]; |
| } |
| if (instance._storage[1] > other._storage[1]) { |
| instance._storage[1] = other._storage[1]; |
| } |
| if (instance._storage[2] > other._storage[2]) { |
| instance._storage[2] = other._storage[2]; |
| } |
| if (instance._storage[3] > other._storage[3]) { |
| instance._storage[3] = other._storage[3]; |
| } |
| return instance; |
| } |
| Float32x4 max(Float32x4 other) { |
| var instance = new _Float32x4Dart.copy(this); |
| if (instance._storage[0] < other._storage[0]) { |
| instance._storage[0] = other._storage[0]; |
| } |
| if (instance._storage[1] < other._storage[1]) { |
| instance._storage[1] = other._storage[1]; |
| } |
| if (instance._storage[2] < other._storage[2]) { |
| instance._storage[2] = other._storage[2]; |
| } |
| if (instance._storage[3] < other._storage[3]) { |
| instance._storage[3] = other._storage[3]; |
| } |
| return instance; |
| } |
| Float32x4 sqrt() { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _sqrt(_storage[0]); |
| instance._storage[1] = _sqrt(_storage[1]); |
| instance._storage[2] = _sqrt(_storage[2]); |
| instance._storage[3] = _sqrt(_storage[3]); |
| return instance; |
| } |
| Float32x4 reciprocal() { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = (1.0 / _storage[0]); |
| instance._storage[1] = (1.0 / _storage[1]); |
| instance._storage[2] = (1.0 / _storage[2]); |
| instance._storage[3] = (1.0 / _storage[3]); |
| return instance; |
| } |
| Float32x4 reciprocalSqrt() { |
| var instance = new _Float32x4Dart.empty(); |
| instance._storage[0] = _sqrt(1.0 / _storage[0]); |
| instance._storage[1] = _sqrt(1.0 / _storage[1]); |
| instance._storage[2] = _sqrt(1.0 / _storage[2]); |
| instance._storage[3] = _sqrt(1.0 / _storage[3]); |
| return instance; |
| } |
| Uint32x4 toUint32x4() { |
| Uint32List view = new Uint32List.view(_storage.asByteArray()); |
| return new Uint32x4(view[0], view[1], view[2], view[3]); |
| } |
| } |
| |
| class _Uint32x4Dart implements Uint32x4 { |
| final Uint32List _storage = new Uint32List(4); |
| _Uint32x4Dart.empty() { |
| } |
| _Uint32x4Dart.copy(_Uint32x4Dart other) { |
| _storage[0] = other._storage[0]; |
| _storage[1] = other._storage[1]; |
| _storage[2] = other._storage[2]; |
| _storage[3] = other._storage[3]; |
| } |
| factory _Uint32x4Dart(int x, int y, int z, int w) { |
| var instance = new _Uint32x4Dart.empty(); |
| instance._storage[0] = x; |
| instance._storage[1] = y; |
| instance._storage[2] = z; |
| instance._storage[3] = w; |
| return instance; |
| } |
| factory _Uint32x4Dart.bool(bool x, bool y, bool z, bool w) { |
| var instance = new _Uint32x4Dart.empty(); |
| instance._storage[0] = x ? 0xFFFFFFFF : 0x0; |
| instance._storage[1] = y ? 0xFFFFFFFF : 0x0; |
| instance._storage[2] = z ? 0xFFFFFFFF : 0x0; |
| instance._storage[3] = w ? 0xFFFFFFFF : 0x0; |
| return instance; |
| } |
| Uint32x4 operator |(Uint32x4 other) { |
| var instance = new _Uint32x4Dart.empty(); |
| instance._storage[0] = _storage[0] | other._storage[0]; |
| instance._storage[1] = _storage[1] | other._storage[1]; |
| instance._storage[2] = _storage[2] | other._storage[2]; |
| instance._storage[3] = _storage[3] | other._storage[3]; |
| return instance; |
| } |
| Uint32x4 operator &(Uint32x4 other) { |
| var instance = new _Uint32x4Dart.empty(); |
| instance._storage[0] = _storage[0] & other._storage[0]; |
| instance._storage[1] = _storage[1] & other._storage[1]; |
| instance._storage[2] = _storage[2] & other._storage[2]; |
| instance._storage[3] = _storage[3] & other._storage[3]; |
| return instance; |
| } |
| Uint32x4 operator ^(Uint32x4 other) { |
| var instance = new _Uint32x4Dart.empty(); |
| instance._storage[0] = _storage[0] ^ other._storage[0]; |
| instance._storage[1] = _storage[1] ^ other._storage[1]; |
| instance._storage[2] = _storage[2] ^ other._storage[2]; |
| instance._storage[3] = _storage[3] ^ other._storage[3]; |
| return instance; |
| } |
| int get x => _storage[0]; |
| int get y => _storage[1]; |
| int get z => _storage[2]; |
| int get w => _storage[3]; |
| Uint32x4 withX(int x) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[0] = x & 0xFFFFFFFF; |
| return instance; |
| } |
| Uint32x4 withY(int y) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[1] = y & 0xFFFFFFFF; |
| return instance; |
| } |
| Uint32x4 withZ(int z) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[2] = z & 0xFFFFFFFF; |
| return instance; |
| } |
| Uint32x4 withW(int w) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[3] = w & 0xFFFFFFFF; |
| return instance; |
| } |
| bool get flagX => _storage[0] != 0x0; |
| bool get flagY => _storage[1] != 0x0; |
| bool get flagZ => _storage[2] != 0x0; |
| bool get flagW => _storage[3] != 0x0; |
| Uint32x4 withFlagX(bool x) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[0] = x ? 0xFFFFFFFF : 0x0; |
| return instance; |
| } |
| Uint32x4 withFlagY(bool y) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[1] = y ? 0xFFFFFFFF : 0x0; |
| return instance; |
| } |
| Uint32x4 withFlagZ(bool z) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[2] = z ? 0xFFFFFFFF : 0x0; |
| return instance; |
| } |
| Uint32x4 withFlagW(bool w) { |
| var instance = new _Uint32x4Dart.copy(this); |
| instance._storage[3] = w ? 0xFFFFFFFF : 0x0; |
| return instance; |
| } |
| Float32x4 select(Float32x4 trueValue, |
| Float32x4 falseValue) { |
| Uint32x4 trueMask = trueValue.toUint32x4(); |
| Uint32x4 falseMask = falseValue.toUint32x4(); |
| var instance = new _Uint32x4Dart.empty(); |
| instance._storage[0] = (_storage[0] & trueMask._storage[0]); |
| instance._storage[1] = (_storage[1] & trueMask._storage[1]); |
| instance._storage[2] = (_storage[2] & trueMask._storage[2]); |
| instance._storage[3] = (_storage[3] & trueMask._storage[3]); |
| instance._storage[0] |= (~_storage[0] & falseMask._storage[0]); |
| instance._storage[1] |= (~_storage[1] & falseMask._storage[1]); |
| instance._storage[2] |= (~_storage[2] & falseMask._storage[2]); |
| instance._storage[3] |= (~_storage[3] & falseMask._storage[3]); |
| return instance.toFloat32x4(); |
| } |
| Float32x4 toFloat32x4() { |
| Float32List view = new Float32List.view(_storage.asByteArray()); |
| return new Float32x4(view[0], view[1], view[2], view[3]); |
| } |
| } |
| |
| class _Float32x4 implements Float32x4 { |
| factory _Float32x4(double x, double y, double z, double w) |
| native "Float32x4_fromDoubles"; |
| factory _Float32x4.zero() native "Float32x4_zero"; |
| Float32x4 operator +(Float32x4 other) { |
| return _add(other); |
| } |
| Float32x4 _add(Float32x4 other) native "Float32x4_add"; |
| Float32x4 operator -() { |
| return _negate(); |
| } |
| Float32x4 _negate() native "Float32x4_negate"; |
| Float32x4 operator -(Float32x4 other) { |
| return _sub(other); |
| } |
| Float32x4 _sub(Float32x4 other) native "Float32x4_sub"; |
| Float32x4 operator *(Float32x4 other) { |
| return _mul(other); |
| } |
| Float32x4 _mul(Float32x4 other) native "Float32x4_mul"; |
| Float32x4 operator /(Float32x4 other) { |
| return _div(other); |
| } |
| Float32x4 _div(Float32x4 other) native "Float32x4_div"; |
| Uint32x4 lessThan(Float32x4 other) { |
| return _cmplt(other); |
| } |
| Uint32x4 _cmplt(Float32x4 other) native "Float32x4_cmplt"; |
| Uint32x4 lessThanOrEqual(Float32x4 other) { |
| return _cmplte(other); |
| } |
| Uint32x4 _cmplte(Float32x4 other) native "Float32x4_cmplte"; |
| Uint32x4 greaterThan(Float32x4 other) { |
| return _cmpgt(other); |
| } |
| Uint32x4 _cmpgt(Float32x4 other) native "Float32x4_cmpgt"; |
| Uint32x4 greaterThanOrEqual(Float32x4 other) { |
| return _cmpgte(other); |
| } |
| Uint32x4 _cmpgte(Float32x4 other) native "Float32x4_cmpgte"; |
| Uint32x4 equal(Float32x4 other) { |
| return _cmpequal(other); |
| } |
| Uint32x4 _cmpequal(Float32x4 other) |
| native "Float32x4_cmpequal"; |
| Uint32x4 notEqual(Float32x4 other) { |
| return _cmpnequal(other); |
| } |
| Uint32x4 _cmpnequal(Float32x4 other) |
| native "Float32x4_cmpnequal"; |
| Float32x4 scale(double s) { |
| return _scale(s); |
| } |
| Float32x4 _scale(double s) native "Float32x4_scale"; |
| Float32x4 abs() { |
| return _abs(); |
| } |
| Float32x4 _abs() native "Float32x4_abs"; |
| Float32x4 clamp(Float32x4 lowerLimit, |
| Float32x4 upperLimit) { |
| return _clamp(lowerLimit, upperLimit); |
| } |
| Float32x4 _clamp(Float32x4 lowerLimit, |
| Float32x4 upperLimit) |
| native "Float32x4_clamp"; |
| double get x native "Float32x4_getX"; |
| double get y native "Float32x4_getY"; |
| double get z native "Float32x4_getZ"; |
| double get w native "Float32x4_getW"; |
| Float32x4 get xxxx native "Float32x4_getXXXX"; |
| Float32x4 get yyyy native "Float32x4_getYYYY"; |
| Float32x4 get zzzz native "Float32x4_getZZZZ"; |
| Float32x4 get wwww native "Float32x4_getWWWW"; |
| Float32x4 withX(double x) native "Float32x4_setX"; |
| Float32x4 withY(double y) native "Float32x4_setY"; |
| Float32x4 withZ(double z) native "Float32x4_setZ"; |
| Float32x4 withW(double w) native "Float32x4_setW"; |
| Float32x4 min(Float32x4 other) { |
| return _min(other); |
| } |
| Float32x4 _min(Float32x4 other) native "Float32x4_min"; |
| Float32x4 max(Float32x4 other) { |
| return _max(other); |
| } |
| Float32x4 _max(Float32x4 other) native "Float32x4_max"; |
| Float32x4 sqrt() { |
| return _sqrt(); |
| } |
| Float32x4 _sqrt() native "Float32x4_sqrt"; |
| Float32x4 reciprocal() { |
| return _reciprocal(); |
| } |
| Float32x4 _reciprocal() native "Float32x4_reciprocal"; |
| Float32x4 reciprocalSqrt() { |
| return _reciprocalSqrt(); |
| } |
| Float32x4 _reciprocalSqrt() native "Float32x4_reciprocalSqrt"; |
| Uint32x4 toUint32x4() { |
| return _toUint32x4(); |
| } |
| Uint32x4 _toUint32x4() native "Float32x4_toUint32x4"; |
| } |
| |
| class _Uint32x4 implements Uint32x4 { |
| factory _Uint32x4(int x, int y, int z, int w) |
| native "Uint32x4_fromInts"; |
| factory _Uint32x4.bool(bool x, bool y, bool z, bool w) |
| native "Uint32x4_fromBools"; |
| Uint32x4 operator |(Uint32x4 other) { |
| return _or(other); |
| } |
| Uint32x4 _or(Uint32x4 other) native "Uint32x4_or"; |
| Uint32x4 operator &(Uint32x4 other) { |
| return _and(other); |
| } |
| Uint32x4 _and(Uint32x4 other) native "Uint32x4_and"; |
| Uint32x4 operator ^(Uint32x4 other) { |
| return _xor(other); |
| } |
| Uint32x4 _xor(Uint32x4 other) native "Uint32x4_xor"; |
| int get x native "Uint32x4_getX"; |
| int get y native "Uint32x4_getY"; |
| int get z native "Uint32x4_getZ"; |
| int get w native "Uint32x4_getW"; |
| Uint32x4 withX(int x) native "Uint32x4_setX"; |
| Uint32x4 withY(int y) native "Uint32x4_setY"; |
| Uint32x4 withZ(int z) native "Uint32x4_setZ"; |
| Uint32x4 withW(int w) native "Uint32x4_setW"; |
| bool get flagX native "Uint32x4_getFlagX"; |
| bool get flagY native "Uint32x4_getFlagY"; |
| bool get flagZ native "Uint32x4_getFlagZ"; |
| bool get flagW native "Uint32x4_getFlagW"; |
| Uint32x4 withFlagX(bool x) native "Uint32x4_setFlagX"; |
| Uint32x4 withFlagY(bool y) native "Uint32x4_setFlagY"; |
| Uint32x4 withFlagZ(bool z) native "Uint32x4_setFlagZ"; |
| Uint32x4 withFlagW(bool w) native "Uint32x4_setFlagW"; |
| Float32x4 select(Float32x4 trueValue, |
| Float32x4 falseValue) { |
| return _select(trueValue, falseValue); |
| } |
| Float32x4 _select(Float32x4 trueValue, |
| Float32x4 falseValue) |
| native "Uint32x4_select"; |
| Float32x4 toFloat32x4() { |
| return _toFloat32x4(); |
| } |
| Float32x4 _toFloat32x4() native "Uint32x4_toFloat32x4"; |
| } |
| |
| |
| class _Float32x4Array extends _ByteArrayBase |
| implements Float32x4List { |
| factory _Float32x4Array(int length) { |
| return _new(length); |
| } |
| |
| factory _Float32x4Array.view(ByteArray array, |
| [int start = 0, int length]) { |
| if (length == null) { |
| length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
| } |
| return new _Float32x4ArrayView(array, start, length); |
| } |
| |
| Float32x4 operator [](int index) { |
| return _getIndexed(index); |
| } |
| |
| int operator []=(int index, Float32x4 value) { |
| _setIndexed(index, value); |
| } |
| |
| Iterator<Float32x4> get iterator { |
| return new _ByteArrayIterator<Float32x4>(this); |
| } |
| |
| List<Float32x4> sublist(int start, [int end]) { |
| if (end == null) end = length; |
| int length = end - start; |
| _rangeCheck(this.length, start, length); |
| List<Float32x4> result = _new(length); |
| result.setRange(0, length, this, start); |
| return result; |
| } |
| |
| List<Float32x4> getRange(int start, int length) { |
| return sublist(start, start + length); |
| } |
| |
| void setRange(int start, int length, List<Float32x4> from, |
| [int startFrom = 0]) { |
| if (from is _Float32x4Array) { |
| _setRange(start * _BYTES_PER_ELEMENT, |
| length * _BYTES_PER_ELEMENT, |
| from, |
| startFrom * _BYTES_PER_ELEMENT); |
| } else { |
| IterableMixinWorkaround.setRangeList( |
| this, start, length, from, startFrom); |
| } |
| } |
| String toString() { |
| return Collections.collectionToString(this); |
| } |
| int bytesPerElement() { |
| return _BYTES_PER_ELEMENT; |
| } |
| int lengthInBytes() { |
| return _length() * _BYTES_PER_ELEMENT; |
| } |
| static const int _BYTES_PER_ELEMENT = 16; |
| static _Float32x4Array _new(int length) |
| native "Float32x4Array_new"; |
| Float32x4 _getIndexed(int index) |
| native "Float32x4Array_getIndexed"; |
| int _setIndexed(int index, Float32x4 value) |
| native "Float32x4Array_setIndexed"; |
| } |
| |
| |
| class _Float32x4ArrayView extends _ByteArrayViewBase |
| implements Float32x4List { |
| _Float32x4ArrayView(ByteArray array, |
| [int offsetInBytes = 0, int _length]) |
| : super(array, _requireInteger(offsetInBytes), |
| _requireIntegerOrNull( |
| _length, |
| ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) { |
| _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT); |
| } |
| |
| Float32x4 operator [](int index) { |
| if (index < 0 || index >= length) { |
| String message = "$index must be in the range [0..$length)"; |
| throw new RangeError(message); |
| } |
| return _array.getFloat32x4(_offset + (index * _BYTES_PER_ELEMENT)); |
| } |
| |
| void operator []=(int index, Float32x4 value) { |
| if (index < 0 || index >= length) { |
| String message = "$index must be in the range [0..$length)"; |
| throw new RangeError(message); |
| } |
| _array.setFloat32x4(_offset + (index * _BYTES_PER_ELEMENT), value); |
| } |
| |
| Iterator<Float32x4> get iterator { |
| return new _ByteArrayIterator<Float32x4>(this); |
| } |
| |
| List<Float32x4> sublist(int start, [int end]) { |
| if (end == null) end = length; |
| int length = end - start; |
| _rangeCheck(this.length, start, length); |
| List<Float32x4> result = new Float32List(length); |
| result.setRange(0, length, this, start); |
| return result; |
| } |
| |
| List<Float32x4> getRange(int start, int length) { |
| return sublist(start, start + length); |
| } |
| |
| void setRange(int start, int length, List<Float32x4> from, |
| [int startFrom = 0]) { |
| IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom); |
| } |
| |
| String toString() { |
| return Collections.collectionToString(this); |
| } |
| |
| int bytesPerElement() { |
| return _BYTES_PER_ELEMENT; |
| } |
| |
| int lengthInBytes() { |
| return length * _BYTES_PER_ELEMENT; |
| } |
| |
| ByteArray asByteArray([int start = 0, int length]) { |
| if (length == null) { |
| length = this.lengthInBytes(); |
| } |
| _rangeCheck(this.length, start, length); |
| return _array.subByteArray(_offset + start, length); |
| } |
| |
| static const int _BYTES_PER_ELEMENT = 16; |
| } |
| |
| |
| class _ExternalFloat32x4Array extends _ByteArrayBase |
| implements Float32x4List { |
| Float32x4 operator [](int index) { |
| return _getIndexed(index); |
| } |
| |
| int operator []=(int index, Float32x4 value) { |
| _setIndexed(index, value); |
| } |
| |
| Iterator<Float32x4> get iterator { |
| return new _ByteArrayIterator<Float32x4>(this); |
| } |
| |
| List<Float32x4> sublist(int start, [int end]) { |
| if (end == null) end = length; |
| int length = end - start; |
| _rangeCheck(this.length, start, length); |
| List<Float32x4> result = new Float32x4List(length); |
| result.setRange(0, length, this, start); |
| return result; |
| } |
| |
| List<Float32x4> getRange(int start, int length) { |
| return sublist(start, start + length); |
| } |
| |
| void setRange(int start, int length, List<Float32x4> from, |
| [int startFrom = 0]) { |
| if (from is _ExternalFloat32x4Array) { |
| _setRange(start * _BYTES_PER_ELEMENT, |
| length * _BYTES_PER_ELEMENT, |
| from, |
| startFrom * _BYTES_PER_ELEMENT); |
| } else { |
| IterableMixinWorkaround.setRangeList( |
| this, start, length, from, startFrom); |
| } |
| } |
| |
| String toString() { |
| return Collections.collectionToString(this); |
| } |
| |
| int bytesPerElement() { |
| return _BYTES_PER_ELEMENT; |
| } |
| |
| int lengthInBytes() { |
| return _length() * _BYTES_PER_ELEMENT; |
| } |
| |
| static const int _BYTES_PER_ELEMENT = 16; |
| |
| Float32x4 _getIndexed(int index) |
| native "ExternalFloat32x4Array_getIndexed"; |
| int _setIndexed(int index, Float32x4 value) |
| native "ExternalFloat32x4Array_setIndexed"; |
| } |
