/// <summary> /// vector-and-scalar constructor (CAUTION: not angle-axis, use FromAngleAxis instead) /// </summary> public uquat(uvec3 v, uint s) { this.x = v.x; this.y = v.y; this.z = v.z; this.w = s; }
public void Constructors() { { var v = new uvec3(9u); Assert.AreEqual(9u, v.x); Assert.AreEqual(9u, v.y); Assert.AreEqual(9u, v.z); } { var v = new uvec3(6u, 5u, 2u); Assert.AreEqual(6u, v.x); Assert.AreEqual(5u, v.y); Assert.AreEqual(2u, v.z); } { var v = new uvec3(new uvec2(8u, 9u)); Assert.AreEqual(8u, v.x); Assert.AreEqual(9u, v.y); Assert.AreEqual(0u, v.z); } { var v = new uvec3(new uvec3(6u, 3u, 2u)); Assert.AreEqual(6u, v.x); Assert.AreEqual(3u, v.y); Assert.AreEqual(2u, v.z); } { var v = new uvec3(new uvec4(8u, 5u, 6u, 4u)); Assert.AreEqual(8u, v.x); Assert.AreEqual(5u, v.y); Assert.AreEqual(6u, v.z); } }
/// <summary> /// Returns a vector rotated by the quaternion. /// </summary> public static uvec3 operator*(uquat q, uvec3 v) { var qv = new uvec3(q.x, q.y, q.z); var uv = uvec3.Cross(qv, v); var uuv = uvec3.Cross(qv, uv); return(v + ((uv * q.w) + uuv) * 2); }
/// <summary> /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix. /// </summary> public umat2x3(uvec3 c0, uvec3 c1) { this.m00 = c0.x; this.m01 = c0.y; this.m02 = c0.z; this.m10 = c1.x; this.m11 = c1.y; this.m12 = c1.z; }
public void PropertyValues() { var v = new uvec3(5u, 2u, 9u); var vals = v.Values; Assert.AreEqual(5u, vals[0]); Assert.AreEqual(2u, vals[1]); Assert.AreEqual(9u, vals[2]); Assert.That(vals.SequenceEqual(v.ToArray())); }
public void SerializationJson() { var v0 = new uvec3(5u, 4u, 3u); var s0 = JsonConvert.SerializeObject(v0); var v1 = JsonConvert.DeserializeObject <uvec3>(s0); var s1 = JsonConvert.SerializeObject(v1); Assert.AreEqual(v0, v1); Assert.AreEqual(s0, s1); }
/// <summary> /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix. /// </summary> public umat2x4(uvec3 c0, uvec3 c1) { this.m00 = c0.x; this.m01 = c0.y; this.m02 = c0.z; this.m03 = 0u; this.m10 = c1.x; this.m11 = c1.y; this.m12 = c1.z; this.m13 = 0u; }
/// <summary> /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix. /// </summary> public umat3(uvec3 c0, uvec3 c1, uvec3 c2) { this.m00 = c0.x; this.m01 = c0.y; this.m02 = c0.z; this.m10 = c1.x; this.m11 = c1.y; this.m12 = c1.z; this.m20 = c2.x; this.m21 = c2.y; this.m22 = c2.z; }
public void InvariantCommutative() { { var v0 = new uvec3(2u, 5u, 4u); var v1 = new uvec3(3u, 0u, 3u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(0u, 8u, 8u); var v1 = new uvec3(9u, 6u, 4u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(0u, 0u, 1u); var v1 = new uvec3(0u, 7u, 4u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(1u, 3u, 6u); var v1 = new uvec3(9u, 6u, 3u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(2u, 6u, 5u); var v1 = new uvec3(5u, 2u, 2u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(4u, 1u, 7u); var v1 = new uvec3(6u, 2u, 9u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(5u, 0u, 6u); var v1 = new uvec3(5u, 1u, 8u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(3u, 9u, 0u); var v1 = new uvec3(8u, 3u, 1u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(0u, 3u, 6u); var v1 = new uvec3(8u, 6u, 8u); Assert.AreEqual(v0 * v1, v1 * v0); } { var v0 = new uvec3(2u, 2u, 9u); var v1 = new uvec3(1u, 1u, 3u); Assert.AreEqual(v0 * v1, v1 * v0); } }
public void TriangleInequality() { { var v0 = new uvec3(0u, 1u, 1u); var v1 = new uvec3(9u, 3u, 5u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(8u, 2u, 2u); var v1 = new uvec3(3u, 9u, 9u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(2u, 6u, 6u); var v1 = new uvec3(8u, 3u, 3u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(3u, 4u, 4u); var v1 = new uvec3(2u, 2u, 1u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(5u, 5u, 5u); var v1 = new uvec3(0u, 5u, 7u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(1u, 0u, 4u); var v1 = new uvec3(2u, 2u, 7u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(0u, 3u, 6u); var v1 = new uvec3(5u, 4u, 1u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(4u, 9u, 1u); var v1 = new uvec3(0u, 6u, 2u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(9u, 3u, 7u); var v1 = new uvec3(8u, 3u, 7u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } { var v0 = new uvec3(0u, 8u, 8u); var v1 = new uvec3(9u, 4u, 7u); Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax); } }
public void InvariantCrossDot() { { var v0 = new uvec3(7u, 0u, 6u); var v1 = new uvec3(9u, 3u, 8u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(1u, 9u, 2u); var v1 = new uvec3(9u, 3u, 4u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(0u, 6u, 7u); var v1 = new uvec3(6u, 0u, 9u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(4u, 2u, 7u); var v1 = new uvec3(8u, 9u, 3u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(9u, 2u, 3u); var v1 = new uvec3(6u, 9u, 1u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(9u, 7u, 1u); var v1 = new uvec3(8u, 9u, 8u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(2u, 1u, 4u); var v1 = new uvec3(4u, 7u, 3u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(3u, 5u, 5u); var v1 = new uvec3(2u, 9u, 8u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(0u, 1u, 4u); var v1 = new uvec3(7u, 7u, 6u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } { var v0 = new uvec3(8u, 8u, 1u); var v1 = new uvec3(3u, 0u, 0u); Assert.Less(glm.Abs(glm.Dot(v0, glm.Cross(v0, v1))), 0.1); } }
/// <summary> /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix. /// </summary> public umat3(uvec3 c0, uvec3 c1) { this.m00 = c0.x; this.m01 = c0.y; this.m02 = c0.z; this.m10 = c1.x; this.m11 = c1.y; this.m12 = c1.z; this.m20 = 0u; this.m21 = 0u; this.m22 = 1u; }
public void Operators() { var v1 = new uvec3(3u, 5u, 6u); var v2 = new uvec3(3u, 5u, 6u); var v3 = new uvec3(6u, 5u, 3u); Assert.That(v1 == new uvec3(v1)); Assert.That(v2 == new uvec3(v2)); Assert.That(v3 == new uvec3(v3)); Assert.That(v1 == v2); Assert.That(v1 != v3); Assert.That(v2 != v3); }
public void StringInterop() { var v = new uvec3(4u, 3u, 3u); var s0 = v.ToString(); var s1 = v.ToString("#"); var v0 = uvec3.Parse(s0); var v1 = uvec3.Parse(s1, "#"); Assert.AreEqual(v, v0); Assert.AreEqual(v, v1); var b0 = uvec3.TryParse(s0, out v0); var b1 = uvec3.TryParse(s1, "#", out v1); Assert.That(b0); Assert.That(b1); Assert.AreEqual(v, v0); Assert.AreEqual(v, v1); b0 = uvec3.TryParse(null, out v0); Assert.False(b0); b0 = uvec3.TryParse("", out v0); Assert.False(b0); b0 = uvec3.TryParse(s0 + ", 0", out v0); Assert.False(b0); Assert.Throws <NullReferenceException>(() => { uvec3.Parse(null); }); Assert.Throws <FormatException>(() => { uvec3.Parse(""); }); Assert.Throws <FormatException>(() => { uvec3.Parse(s0 + ", 0"); }); var s2 = v.ToString(";", CultureInfo.InvariantCulture); Assert.That(s2.Length > 0); var s3 = v.ToString("; ", "G"); var s4 = v.ToString("; ", "G", CultureInfo.InvariantCulture); var v3 = uvec3.Parse(s3, "; ", NumberStyles.Number); var v4 = uvec3.Parse(s4, "; ", NumberStyles.Number, CultureInfo.InvariantCulture); Assert.AreEqual(v, v3); Assert.AreEqual(v, v4); var b4 = uvec3.TryParse(s4, "; ", NumberStyles.Number, CultureInfo.InvariantCulture, out v4); Assert.That(b4); Assert.AreEqual(v, v4); }
/// <summary> /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix. /// </summary> public umat4x3(uvec3 c0, uvec3 c1, uvec3 c2, uvec3 c3) { this.m00 = c0.x; this.m01 = c0.y; this.m02 = c0.z; this.m10 = c1.x; this.m11 = c1.y; this.m12 = c1.z; this.m20 = c2.x; this.m21 = c2.y; this.m22 = c2.z; this.m30 = c3.x; this.m31 = c3.y; this.m32 = c3.z; }
/// <summary> /// update minimum values. /// </summary> /// <param name="item"></param> /// <param name="currentMin"></param> public static void UpdateMin(this uvec3 item, ref uvec3 currentMin) { if (item.x < currentMin.x) { currentMin.x = item.x; } if (item.y < currentMin.y) { currentMin.y = item.y; } if (item.z < currentMin.z) { currentMin.z = item.z; } }
/// <summary> /// update minimum values. /// </summary> /// <param name="item"></param> /// <param name="currentMax"></param> public static void UpdateMax(this uvec3 item, ref uvec3 currentMax) { if (currentMax.x < item.x) { currentMax.x = item.x; } if (currentMax.y < item.y) { currentMax.y = item.y; } if (currentMax.z < item.z) { currentMax.z = item.z; } }
public void InvariantNorm() { { var v0 = new uvec3(2u, 3u, 1u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(7u, 7u, 8u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(1u, 7u, 6u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(1u, 9u, 1u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(3u, 0u, 4u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(8u, 3u, 9u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(7u, 8u, 4u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(3u, 5u, 0u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(0u, 7u, 2u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } { var v0 = new uvec3(1u, 4u, 8u); Assert.LessOrEqual(v0.NormMax, v0.Norm); } }
public void InvariantTriple() { { var v0 = new uvec3(2u, 5u, 8u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(3u, 1u, 8u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(2u, 0u, 0u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(4u, 9u, 5u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(1u, 4u, 6u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(9u, 4u, 3u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(0u, 1u, 4u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(5u, 1u, 6u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(6u, 4u, 3u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } { var v0 = new uvec3(6u, 7u, 7u); Assert.AreEqual(v0 + v0 + v0, 3 * v0); } }
public void InvariantId() { { var v0 = new uvec3(9u, 1u, 7u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(6u, 9u, 0u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(2u, 4u, 5u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(9u, 8u, 2u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(7u, 1u, 8u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(0u, 3u, 0u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(4u, 4u, 2u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(6u, 3u, 5u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(1u, 4u, 4u); Assert.AreEqual(v0, +v0); } { var v0 = new uvec3(6u, 0u, 1u); Assert.AreEqual(v0, +v0); } }
public void InvariantDouble() { { var v0 = new uvec3(8u, 5u, 2u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(9u, 5u, 8u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(0u, 5u, 7u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(9u, 0u, 6u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(9u, 1u, 7u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(7u, 4u, 4u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(9u, 5u, 9u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(1u, 9u, 8u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(6u, 4u, 0u); Assert.AreEqual(v0 + v0, 2 * v0); } { var v0 = new uvec3(2u, 6u, 7u); Assert.AreEqual(v0 + v0, 2 * v0); } }
public void Indexer() { var v = new uvec3(9u, 1u, 1u); Assert.AreEqual(9u, v[0]); Assert.AreEqual(1u, v[1]); Assert.AreEqual(1u, v[2]); Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[-2147483648]; }); Assert.Throws <ArgumentOutOfRangeException>(() => { v[-2147483648] = 0u; }); Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[-1]; }); Assert.Throws <ArgumentOutOfRangeException>(() => { v[-1] = 0u; }); Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[3]; }); Assert.Throws <ArgumentOutOfRangeException>(() => { v[3] = 0u; }); Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[2147483647]; }); Assert.Throws <ArgumentOutOfRangeException>(() => { v[2147483647] = 0u; }); Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[5]; }); Assert.Throws <ArgumentOutOfRangeException>(() => { v[5] = 0u; }); v[1] = 0u; Assert.AreEqual(0u, v[1]); v[0] = 1u; Assert.AreEqual(1u, v[0]); v[1] = 2u; Assert.AreEqual(2u, v[1]); v[2] = 3u; Assert.AreEqual(3u, v[2]); v[0] = 4u; Assert.AreEqual(4u, v[0]); v[2] = 5u; Assert.AreEqual(5u, v[2]); v[0] = 6u; Assert.AreEqual(6u, v[0]); v[2] = 7u; Assert.AreEqual(7u, v[2]); v[2] = 8u; Assert.AreEqual(8u, v[2]); v[1] = 9u; Assert.AreEqual(9u, v[1]); }
protected uvec3 min(uvec3 x, uint y) { throw new NotImplementedException(); }
/// <summary> Returns the bit number of the least significant bit set to 1 in the /// binary representation of value. If value is zero, -1 will be returned. </summary> protected static ivec3 findLSB(uvec3 value) { throw _invalidAccess; }
/// <summary>Returns y if x < y, otherwise it returns x.</summary> protected internal static uvec3 Max(uvec3 x, uvec3 y) { throw _invalidAccess; }
/// <summary> /// Returns the insertion the bits least-significant bits of insert into base. /// The result will have bits [offset, offset + bits - 1] taken from bits [0, bits – 1] /// of insert, and all other bits taken directly from the corresponding bits of base. /// If bits is zero, the result will simply be base. /// The result will be undefined if offset or bits is negative, or if the sum of /// offset and bits is greater than the number of bits used to store the operand. /// </summary> protected static uvec3 bitfieldInsert(uvec3 _base, uvec3 insert, int offset, int bits) { throw _invalidAccess; }
/// <summary>Returns Min (Max (x, minVal), maxVal). Results are undefined if minVal > maxVal.</summary> protected internal static uvec3 Clamp(uvec3 x, uvec3 minVal, uvec3 maxVal) { throw _invalidAccess; }
protected uvec3 max(uvec3 x, uvec3 y) { throw new NotImplementedException(); }
/// <summary> Subtracts the 32-bit unsigned integer y from x, returning the difference /// if non-negative, or 2**32 plus the difference otherwise. /// The value borrow is set to 0 if x >= y, or to 1 otherwise. </summary> protected static uvec3 usubBorrow(uvec3 x, uvec3 y, out uvec3 borrow) { throw _invalidAccess; }
public void InvariantAssociative() { { var v0 = new uvec3(0u, 8u, 1u); var v1 = new uvec3(1u, 8u, 2u); var v2 = new uvec3(4u, 8u, 1u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(5u, 4u, 3u); var v1 = new uvec3(0u, 1u, 9u); var v2 = new uvec3(2u, 5u, 3u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(9u, 1u, 9u); var v1 = new uvec3(7u, 2u, 6u); var v2 = new uvec3(9u, 1u, 9u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(9u, 3u, 4u); var v1 = new uvec3(0u, 3u, 6u); var v2 = new uvec3(8u, 6u, 2u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(1u, 6u, 3u); var v1 = new uvec3(7u, 9u, 5u); var v2 = new uvec3(0u, 2u, 1u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(8u, 6u, 0u); var v1 = new uvec3(6u, 5u, 3u); var v2 = new uvec3(6u, 8u, 2u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(0u, 2u, 6u); var v1 = new uvec3(5u, 1u, 6u); var v2 = new uvec3(2u, 5u, 4u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(6u, 4u, 1u); var v1 = new uvec3(7u, 1u, 4u); var v2 = new uvec3(6u, 0u, 9u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(9u, 1u, 2u); var v1 = new uvec3(4u, 7u, 9u); var v2 = new uvec3(4u, 0u, 5u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } { var v0 = new uvec3(9u, 3u, 8u); var v1 = new uvec3(1u, 4u, 4u); var v2 = new uvec3(4u, 7u, 3u); Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2); } }
protected uvec3 clamp(uvec3 x, uint minVal, uint maxVal) { throw new NotImplementedException(); }
/// <summary>Returns y if y < x, otherwise it returns x.</summary> protected internal static uvec3 Min(uvec3 x, uint y) { throw _invalidAccess; }
protected bvec3 lessThan(uvec3 x, uvec3 y) { throw new NotImplementedException(); }
/// <summary> Fetch a single texel as in texelFetch offset by offset as described in textureOffset. </summary> protected static uvec4 texelFetchOffset(sampler3D sampler, uvec3 P, int lod, ivec3 offset) { throw _invalidAccess; }
/// <summary> /// Extracts bits [offset, offset + bits - 1] from value, returning them /// in the least significant bits of the result. /// The most significant bits of the result will be set to zero. /// If bits is zero, the result will be zero. The result will be undefined if /// offset or bits is negative, or if the sum of offset and bits is greater than /// the number of bits used to store the operand. /// </summary> /// <returns></returns> protected static uvec3 bitfieldExtract(uvec3 value, int offset, int bits) { throw _invalidAccess; }
/// <summary> /// Returns a bvec3 from component-wise application of NotEqual (lhs != rhs). /// </summary> public static bvec3 NotEqual(uvec3 lhs, uvec3 rhs) => uvec3.NotEqual(lhs, rhs);
/// <summary> /// Multiplies 32-bit integers x and y, producing a 64-bit result. /// The 32 least-significant bits are returned in lsb. The 32 most-significant bits are returned in msb. /// </summary> protected static void umulExtended(uvec3 x, uvec3 y, out uvec3 msb, out uvec3 lsb) { throw _invalidAccess; }
public uvec2(uvec3 xyz) { x = xyz.x; y = xyz.y; }
/// <summary>Returns the number of bits set to 1 in the binary representation of value.</summary> protected static ivec3 bitCount(uvec3 value) { throw _invalidAccess; }
/// <summary> /// Returns the reversal of the bits of value. The bit numbered n of the result will be taken from /// bit (bits - 1) - n of value, where bits is the total number of bits used to represent value. /// </summary> protected static uvec3 bitfieldReverse(uvec3 value) { throw _invalidAccess; }
/// <summary> /// Returns the bit number of the most significant bit in the binary representation of value. /// The result will be the bit number of the most significant bit set to 1. /// For a value of zero, -1 will be returned. /// </summary> protected static int findMSB(uvec3 value) { throw _invalidAccess; }
/// <summary> /// </summary> /// <param name="uniformName"></param> /// <param name="values"></param> /// <returns></returns> public int SetUniform(string uniformName, uvec3[] values) { int location = GetUniformLocation(uniformName); if (location >= 0) { if (glUniform3uiv == null) { glUniform3uiv = OpenGL.GetDelegateFor<OpenGL.glUniform3uiv>(); } int count = values.Length; var value = new uint[count * 3]; int index = 0; for (int i = 0; i < value.Length; i++) { value[index++] = values[i].x; value[index++] = values[i].y; value[index++] = values[i].z; } glUniform3uiv(location, count, value); } return location; }
/// <summary> /// Returns a floating-point value corresponding to an unsigned integer encoding /// of a floating-point value. If a NaN is passed in, it will not signal, /// and the resulting floating point value is unspecified. If an Inf is passed in, /// the resulting floating-point value is the corresponding Inf. /// </summary> protected static vec3 uintBitsToFloat(uvec3 value) { throw _invalidAccess; }
protected bvec3 greaterThanEqual(uvec3 x, uvec3 y) { throw new NotImplementedException(); }
/// <summary> Adds 32-bit unsigned integer x and y, returning the sum modulo 2**32. /// The value carry is set to 0 if the sum was less than 232, or to 1 otherwise. </summary> protected static uvec3 uaddCarry(uvec3 x, uvec3 y, out uvec3 carry) { throw _invalidAccess; }
protected bvec3 notEqual(uvec3 x, uvec3 y) { throw new NotImplementedException(); }