public void Constructors()
{
{
var v = new uvec2(1u);
Assert.AreEqual(1u, v.x);
Assert.AreEqual(1u, v.y);
}
{
var v = new uvec2(5u, 2u);
Assert.AreEqual(5u, v.x);
Assert.AreEqual(2u, v.y);
}
{
var v = new uvec2(new uvec2(3u, 3u));
Assert.AreEqual(3u, v.x);
Assert.AreEqual(3u, v.y);
}
{
var v = new uvec2(new uvec3(9u, 6u, 6u));
Assert.AreEqual(9u, v.x);
Assert.AreEqual(6u, v.y);
}
{
var v = new uvec2(new uvec4(2u, 3u, 8u, 7u));
Assert.AreEqual(2u, v.x);
Assert.AreEqual(3u, v.y);
}
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat2(uvec2 c0, uvec2 c1)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m10 = c1.x;
this.m11 = c1.y;
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat2x3(uvec2 c0, uvec2 c1)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m02 = 0u;
this.m10 = c1.x;
this.m11 = c1.y;
this.m12 = 0u;
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat3x2(uvec2 c0, uvec2 c1)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m10 = c1.x;
this.m11 = c1.y;
this.m20 = 0u;
this.m21 = 0u;
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat3x2(uvec2 c0, uvec2 c1, uvec2 c2)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m10 = c1.x;
this.m11 = c1.y;
this.m20 = c2.x;
this.m21 = c2.y;
}
public void PropertyValues()
{
var v = new uvec2(8u, 0u);
var vals = v.Values;
Assert.AreEqual(8u, vals[0]);
Assert.AreEqual(0u, vals[1]);
Assert.That(vals.SequenceEqual(v.ToArray()));
}
public Texture(uint width, uint height) : this()
{
gl.BindTexture(TextureTarget.Texture2D, ID);
gl.TexImage2D(TextureTarget.Texture2D, 0, (int)InternalFormat.Rgb, width, height, 0, PixelFormat.Rgb, PixelType.UnsignedByte, null);
gl.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
gl.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
gl.BindTexture(TextureTarget.Texture2D, 0);
Size = new uvec2(width, height);
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat4x2(uvec2 c0, uvec2 c1, uvec2 c2)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m10 = c1.x;
this.m11 = c1.y;
this.m20 = c2.x;
this.m21 = c2.y;
this.m30 = 0u;
this.m31 = 0u;
}
public void SerializationJson()
{
var v0 = new uvec2(8u, 2u);
var s0 = JsonConvert.SerializeObject(v0);
var v1 = JsonConvert.DeserializeObject <uvec2>(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 umat4x2(uvec2 c0, uvec2 c1, uvec2 c2, uvec2 c3)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m10 = c1.x;
this.m11 = c1.y;
this.m20 = c2.x;
this.m21 = c2.y;
this.m30 = c3.x;
this.m31 = c3.y;
}
public void TriangleInequality()
{
{
var v0 = new uvec2(3u, 2u);
var v1 = new uvec2(7u, 9u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(2u, 7u);
var v1 = new uvec2(5u, 8u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(6u, 9u);
var v1 = new uvec2(1u, 5u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(2u, 3u);
var v1 = new uvec2(9u, 6u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(4u, 7u);
var v1 = new uvec2(9u, 2u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(0u, 4u);
var v1 = new uvec2(8u, 9u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(5u, 6u);
var v1 = new uvec2(3u, 8u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(9u, 8u);
var v1 = new uvec2(2u, 4u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(1u, 0u);
var v1 = new uvec2(9u, 3u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
{
var v0 = new uvec2(6u, 6u);
var v1 = new uvec2(1u, 9u);
Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
}
}
public void InvariantCommutative()
{
{
var v0 = new uvec2(3u, 7u);
var v1 = new uvec2(3u, 9u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(9u, 4u);
var v1 = new uvec2(4u, 1u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(4u, 2u);
var v1 = new uvec2(0u, 5u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(1u, 8u);
var v1 = new uvec2(6u, 1u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(1u, 5u);
var v1 = new uvec2(6u, 6u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(1u, 3u);
var v1 = new uvec2(2u, 7u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(2u, 5u);
var v1 = new uvec2(7u, 1u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(9u, 6u);
var v1 = new uvec2(8u, 8u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(3u, 4u);
var v1 = new uvec2(5u, 3u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
{
var v0 = new uvec2(7u, 5u);
var v1 = new uvec2(7u, 6u);
Assert.AreEqual(v0 * v1, v1 * v0);
}
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat3(uvec2 c0, uvec2 c1, uvec2 c2)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m02 = 0u;
this.m10 = c1.x;
this.m11 = c1.y;
this.m12 = 0u;
this.m20 = c2.x;
this.m21 = c2.y;
this.m22 = 1u;
}
public void Operators()
{
var v1 = new uvec2(0u, 7u);
var v2 = new uvec2(0u, 7u);
var v3 = new uvec2(7u, 0u);
Assert.That(v1 == new uvec2(v1));
Assert.That(v2 == new uvec2(v2));
Assert.That(v3 == new uvec2(v3));
Assert.That(v1 == v2);
Assert.That(v1 != v3);
Assert.That(v2 != v3);
}
public void StringInterop()
{
var v = new uvec2(7u, 0u);
var s0 = v.ToString();
var s1 = v.ToString("#");
var v0 = uvec2.Parse(s0);
var v1 = uvec2.Parse(s1, "#");
Assert.AreEqual(v, v0);
Assert.AreEqual(v, v1);
var b0 = uvec2.TryParse(s0, out v0);
var b1 = uvec2.TryParse(s1, "#", out v1);
Assert.That(b0);
Assert.That(b1);
Assert.AreEqual(v, v0);
Assert.AreEqual(v, v1);
b0 = uvec2.TryParse(null, out v0);
Assert.False(b0);
b0 = uvec2.TryParse("", out v0);
Assert.False(b0);
b0 = uvec2.TryParse(s0 + ", 0", out v0);
Assert.False(b0);
Assert.Throws <NullReferenceException>(() => { uvec2.Parse(null); });
Assert.Throws <FormatException>(() => { uvec2.Parse(""); });
Assert.Throws <FormatException>(() => { uvec2.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 = uvec2.Parse(s3, "; ", NumberStyles.Number);
var v4 = uvec2.Parse(s4, "; ", NumberStyles.Number, CultureInfo.InvariantCulture);
Assert.AreEqual(v, v3);
Assert.AreEqual(v, v4);
var b4 = uvec2.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(uvec2 c0, uvec2 c1, uvec2 c2, uvec2 c3)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m02 = 0u;
this.m10 = c1.x;
this.m11 = c1.y;
this.m12 = 0u;
this.m20 = c2.x;
this.m21 = c2.y;
this.m22 = 1u;
this.m30 = c3.x;
this.m31 = c3.y;
this.m32 = 0u;
}
/// <summary>
/// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
/// </summary>
public umat3x4(uvec2 c0, uvec2 c1)
{
this.m00 = c0.x;
this.m01 = c0.y;
this.m02 = 0u;
this.m03 = 0u;
this.m10 = c1.x;
this.m11 = c1.y;
this.m12 = 0u;
this.m13 = 0u;
this.m20 = 0u;
this.m21 = 0u;
this.m22 = 1u;
this.m23 = 0u;
}
public override void main()
{
uvec2 xy = gl_GlobalInvocationID.xy;
if (reset)
{
imageStore(outImage, ivec2(xy), vec4(1, 1, 1, 1));
}
else
{
vec2 index = vec2(gl_LocalInvocationID.x, gl_LocalInvocationID.xy.y);
vec2 size = vec2(gl_WorkGroupSize.x, gl_WorkGroupSize.y);
imageStore(outImage, ivec2(xy),
vec4(index.x / size.x, index.y / size.y, 0.0, 0.0));
}
}
public void InlineRGBA()
{
{
var v0 = new uvec2(7u, 0u);
var v1 = 1u;
var v2 = v0.r;
v0.r = v1;
var v3 = v0.r;
Assert.AreEqual(v1, v3);
Assert.AreEqual(1u, v0.x);
Assert.AreEqual(0u, v0.y);
Assert.AreEqual(7u, v2);
}
{
var v0 = new uvec2(2u, 3u);
var v1 = 8u;
var v2 = v0.g;
v0.g = v1;
var v3 = v0.g;
Assert.AreEqual(v1, v3);
Assert.AreEqual(2u, v0.x);
Assert.AreEqual(8u, v0.y);
Assert.AreEqual(3u, v2);
}
{
var v0 = new uvec2(9u, 8u);
var v1 = new uvec2(8u, 2u);
var v2 = v0.rg;
v0.rg = v1;
var v3 = v0.rg;
Assert.AreEqual(v1, v3);
Assert.AreEqual(8u, v0.x);
Assert.AreEqual(2u, v0.y);
Assert.AreEqual(9u, v2.x);
Assert.AreEqual(8u, v2.y);
}
}
public void InlineXYZW()
{
{
var v0 = new uvec2(1u, 1u);
var v1 = new uvec2(5u, 9u);
var v2 = v0.xy;
v0.xy = v1;
var v3 = v0.xy;
Assert.AreEqual(v1, v3);
Assert.AreEqual(5u, v0.x);
Assert.AreEqual(9u, v0.y);
Assert.AreEqual(1u, v2.x);
Assert.AreEqual(1u, v2.y);
}
}
/// <summary>
/// </summary>
/// <param name="uniformName"></param>
/// <param name="values"></param>
/// <returns></returns>
public int SetUniform(string uniformName, uvec2[] values)
{
int location = GetUniformLocation(uniformName);
if (location >= 0)
{
if (glUniform2uiv == null) { glUniform2uiv = OpenGL.GetDelegateFor<OpenGL.glUniform2uiv>(); }
int count = values.Length;
var value = new uint[count * 2];
int index = 0;
for (int i = 0; i < value.Length; i++)
{
value[index++] = values[i].x;
value[index++] = values[i].y;
}
glUniform2uiv(location, count, value);
}
return location;
}
public void InvariantTriple()
{
{
var v0 = new uvec2(5u, 4u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(5u, 4u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(6u, 8u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(3u, 4u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(0u, 8u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(2u, 6u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(4u, 8u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(4u, 6u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(4u, 5u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uvec2(2u, 9u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
}
public void InvariantNorm()
{
{
var v0 = new uvec2(9u, 5u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(4u, 6u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(2u, 8u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(0u, 3u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(6u, 7u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(6u, 0u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(0u, 7u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(7u, 1u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(4u, 7u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uvec2(4u, 1u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
}
public void InvariantId()
{
{
var v0 = new uvec2(6u, 3u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(0u, 5u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(4u, 0u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(1u, 1u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(5u, 5u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(5u, 1u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(5u, 8u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(0u, 3u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(3u, 8u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uvec2(1u, 7u);
Assert.AreEqual(v0, +v0);
}
}
public void InvariantDouble()
{
{
var v0 = new uvec2(1u, 3u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(9u, 0u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(0u, 8u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(1u, 9u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(7u, 3u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(3u, 7u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(1u, 4u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(4u, 4u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(3u, 6u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
{
var v0 = new uvec2(2u, 2u);
Assert.AreEqual(v0 + v0, 2 * v0);
}
}
public void Indexer()
{
var v = new uvec2(2u, 9u);
Assert.AreEqual(2u, v[0]);
Assert.AreEqual(9u, v[1]);
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[2]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { v[2] = 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[1] = 1u;
Assert.AreEqual(1u, v[1]);
v[0] = 2u;
Assert.AreEqual(2u, v[0]);
v[1] = 3u;
Assert.AreEqual(3u, v[1]);
v[0] = 4u;
Assert.AreEqual(4u, v[0]);
v[1] = 5u;
Assert.AreEqual(5u, v[1]);
v[1] = 6u;
Assert.AreEqual(6u, v[1]);
v[0] = 7u;
Assert.AreEqual(7u, v[0]);
v[0] = 8u;
Assert.AreEqual(8u, v[0]);
v[0] = 9u;
Assert.AreEqual(9u, v[0]);
}
protected bvec2 notEqual(uvec2 x, uvec2 y)
{
throw new NotImplementedException();
}
protected bvec2 greaterThanEqual(uvec2 x, uvec2 y)
{
throw new NotImplementedException();
}
protected bvec2 lessThan(uvec2 x, uvec2 y)
{
throw new NotImplementedException();
}
/// <summary>Returns y if x < y, otherwise it returns x.</summary>
protected internal static uvec2 Max(uvec2 x, uvec2 y)
{
throw _invalidAccess;
}
/// <summary>Returns Min (Max (x, minVal), maxVal). Results are undefined if minVal > maxVal.</summary>
protected internal static uvec2 Clamp(uvec2 x, uvec2 minVal, uvec2 maxVal)
{
throw _invalidAccess;
}
/// <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 vec2 uintBitsToFloat(uvec2 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(uvec2 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 uvec2 bitfieldReverse(uvec2 value)
{
throw _invalidAccess;
}
public uvec3(uvec2 xy, uint z_)
{
x = xy.x;
y = xy.y;
z = z_;
}
/// <summary>Returns the number of bits set to 1 in the binary representation of value.</summary>
protected static ivec2 bitCount(uvec2 value)
{
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 uvec2 bitfieldInsert(uvec2 _base, uvec2 insert, int offset, int bits)
{
throw _invalidAccess;
}
/// <summary>
/// Returns a double-precision value obtained by packing the components of v into a 64-bit value.
/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point
/// value is unspecified. Otherwise, the bitlevel representation of v is preserved.
/// The first vector component specifies the 32 least significant bits;
/// the second component specifies the 32 most significant bits.
/// </summary>
protected static double packDouble2x32(uvec2 v)
{
throw _invalidAccess;
}
protected uvec2 min(uvec2 x, uint y)
{
throw new NotImplementedException();
}
/// <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(uvec2 x, uvec2 y, out uvec2 msb, out uvec2 lsb)
{
throw _invalidAccess;
}
/// <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 ivec2 findLSB(uvec2 value)
{
throw _invalidAccess;
}
/// <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 uvec2 uaddCarry(uvec2 x, uvec2 y, out uvec2 carry)
{
throw _invalidAccess;
}
/// <summary>Returns y if y < x, otherwise it returns x.</summary>
protected internal static uvec2 Min(uvec2 x, uint y)
{
throw _invalidAccess;
}
/// <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 uvec2 usubBorrow(uvec2 x, uvec2 y, out uvec2 borrow)
{
throw _invalidAccess;
}
/// <summary>
/// Returns a double-precision value obtained by packing the components of v into a 64-bit value.
/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point
/// value is unspecified. Otherwise, the bitlevel representation of v is preserved.
/// The first vector component specifies the 32 least significant bits;
/// the second component specifies the 32 most significant bits.
/// </summary>
protected static double packDouble2x32(uvec2 v)
{
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 uvec2 bitfieldExtract(uvec2 value, int offset, int bits)
{
throw _invalidAccess;
}
