Esempio n. 1
0
        private void InitSkinInfo(Assimp.Mesh mesh, AssimpSceneContainer container)
        {
            var          boneIDs     = new uvec4[mesh.VertexCount];
            var          boneWeights = new vec4[mesh.VertexCount];
            AllBoneInfos allBones    = container.GetAllBoneInfos();
            Dictionary <string, uint> nameIndexDict = allBones.nameIndexDict;

            for (int i = 0; i < mesh.BoneCount; i++)
            {
                Assimp.Bone bone      = mesh.Bones[i]; // bones that influence this mesh.
                uint        boneIndex = nameIndexDict[bone.Name];

                for (int j = 0; j < bone.VertexWeightCount; j++)
                {
                    Assimp.VertexWeight vertexWeight = bone.VertexWeights[j];
                    uint vertexID = vertexWeight.VertexID;
                    for (int t = 0; t < 4; t++)
                    {
                        if (boneWeights[vertexID][t] == 0.0f) // fill in x y z w.
                        {
                            boneIDs[vertexID][t]     = boneIndex;
                            boneWeights[vertexID][t] = vertexWeight.Weight;
                            break;
                        }
                    }
                }
            }
            this.boneIDs     = boneIDs;
            this.boneWeights = boneWeights;
        }
Esempio n. 2
0
        public void PropertyValues()
        {
            var v    = new uvec4(8u, 5u, 6u, 5u);
            var vals = v.Values;

            Assert.AreEqual(8u, vals[0]);
            Assert.AreEqual(5u, vals[1]);
            Assert.AreEqual(6u, vals[2]);
            Assert.AreEqual(5u, vals[3]);
            Assert.That(vals.SequenceEqual(v.ToArray()));
        }
Esempio n. 3
0
        public void SerializationJson()
        {
            var v0 = new uvec4(8u, 7u, 0u, 6u);
            var s0 = JsonConvert.SerializeObject(v0);

            var v1 = JsonConvert.DeserializeObject <uvec4>(s0);
            var s1 = JsonConvert.SerializeObject(v1);

            Assert.AreEqual(v0, v1);
            Assert.AreEqual(s0, s1);
        }
Esempio n. 4
0
 /// <summary>
 /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
 /// </summary>
 public umat2x4(uvec4 c0, uvec4 c1)
 {
     this.m00 = c0.x;
     this.m01 = c0.y;
     this.m02 = c0.z;
     this.m03 = c0.w;
     this.m10 = c1.x;
     this.m11 = c1.y;
     this.m12 = c1.z;
     this.m13 = c1.w;
 }
Esempio n. 5
0
 public void InvariantCommutative()
 {
     {
         var v0 = new uvec4(2u, 3u, 8u, 6u);
         var v1 = new uvec4(2u, 0u, 3u, 5u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(0u, 5u, 5u, 5u);
         var v1 = new uvec4(9u, 6u, 1u, 0u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(7u, 4u, 1u, 1u);
         var v1 = new uvec4(7u, 4u, 0u, 7u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(6u, 1u, 0u, 6u);
         var v1 = new uvec4(7u, 6u, 2u, 6u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(1u, 9u, 9u, 9u);
         var v1 = new uvec4(8u, 0u, 8u, 3u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(9u, 4u, 4u, 0u);
         var v1 = new uvec4(4u, 2u, 5u, 6u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(9u, 4u, 8u, 2u);
         var v1 = new uvec4(4u, 6u, 9u, 7u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(3u, 1u, 0u, 1u);
         var v1 = new uvec4(9u, 6u, 7u, 3u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(2u, 9u, 3u, 0u);
         var v1 = new uvec4(6u, 2u, 1u, 6u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new uvec4(5u, 7u, 1u, 3u);
         var v1 = new uvec4(0u, 9u, 2u, 3u);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
 }
Esempio n. 6
0
 public void TriangleInequality()
 {
     {
         var v0 = new uvec4(0u, 6u, 5u, 2u);
         var v1 = new uvec4(0u, 8u, 8u, 0u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(6u, 8u, 8u, 9u);
         var v1 = new uvec4(7u, 3u, 6u, 7u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(4u, 7u, 7u, 2u);
         var v1 = new uvec4(0u, 8u, 7u, 3u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(6u, 8u, 9u, 9u);
         var v1 = new uvec4(3u, 2u, 9u, 2u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(9u, 2u, 0u, 4u);
         var v1 = new uvec4(9u, 5u, 5u, 8u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(1u, 0u, 5u, 6u);
         var v1 = new uvec4(9u, 4u, 1u, 4u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(3u, 8u, 1u, 1u);
         var v1 = new uvec4(2u, 2u, 4u, 1u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(9u, 1u, 5u, 2u);
         var v1 = new uvec4(9u, 9u, 6u, 4u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(9u, 6u, 0u, 4u);
         var v1 = new uvec4(3u, 1u, 7u, 9u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new uvec4(1u, 8u, 1u, 9u);
         var v1 = new uvec4(3u, 1u, 4u, 1u);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
 }
Esempio n. 7
0
        public void Operators()
        {
            var v1 = new uvec4(0u, 2u, 9u, 5u);
            var v2 = new uvec4(0u, 2u, 9u, 5u);
            var v3 = new uvec4(5u, 9u, 2u, 0u);

            Assert.That(v1 == new uvec4(v1));
            Assert.That(v2 == new uvec4(v2));
            Assert.That(v3 == new uvec4(v3));
            Assert.That(v1 == v2);
            Assert.That(v1 != v3);
            Assert.That(v2 != v3);
        }
Esempio n. 8
0
        public void StringInterop()
        {
            var v = new uvec4(7u, 7u, 0u, 9u);

            var s0 = v.ToString();
            var s1 = v.ToString("#");

            var v0 = uvec4.Parse(s0);
            var v1 = uvec4.Parse(s1, "#");

            Assert.AreEqual(v, v0);
            Assert.AreEqual(v, v1);

            var b0 = uvec4.TryParse(s0, out v0);
            var b1 = uvec4.TryParse(s1, "#", out v1);

            Assert.That(b0);
            Assert.That(b1);
            Assert.AreEqual(v, v0);
            Assert.AreEqual(v, v1);

            b0 = uvec4.TryParse(null, out v0);
            Assert.False(b0);
            b0 = uvec4.TryParse("", out v0);
            Assert.False(b0);
            b0 = uvec4.TryParse(s0 + ", 0", out v0);
            Assert.False(b0);

            Assert.Throws <NullReferenceException>(() => { uvec4.Parse(null); });
            Assert.Throws <FormatException>(() => { uvec4.Parse(""); });
            Assert.Throws <FormatException>(() => { uvec4.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 = uvec4.Parse(s3, "; ", NumberStyles.Number);
            var v4 = uvec4.Parse(s4, "; ", NumberStyles.Number, CultureInfo.InvariantCulture);

            Assert.AreEqual(v, v3);
            Assert.AreEqual(v, v4);

            var b4 = uvec4.TryParse(s4, "; ", NumberStyles.Number, CultureInfo.InvariantCulture, out v4);

            Assert.That(b4);
            Assert.AreEqual(v, v4);
        }
Esempio n. 9
0
 /// <summary>
 /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
 /// </summary>
 public umat3x4(uvec4 c0, uvec4 c1, uvec4 c2)
 {
     this.m00 = c0.x;
     this.m01 = c0.y;
     this.m02 = c0.z;
     this.m03 = c0.w;
     this.m10 = c1.x;
     this.m11 = c1.y;
     this.m12 = c1.z;
     this.m13 = c1.w;
     this.m20 = c2.x;
     this.m21 = c2.y;
     this.m22 = c2.z;
     this.m23 = c2.w;
 }
Esempio n. 10
0
 /// <summary>
 /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
 /// </summary>
 public umat3x4(uvec4 c0, uvec4 c1)
 {
     this.m00 = c0.x;
     this.m01 = c0.y;
     this.m02 = c0.z;
     this.m03 = c0.w;
     this.m10 = c1.x;
     this.m11 = c1.y;
     this.m12 = c1.z;
     this.m13 = c1.w;
     this.m20 = 0u;
     this.m21 = 0u;
     this.m22 = 1u;
     this.m23 = 0u;
 }
Esempio n. 11
0
 public void InvariantNorm()
 {
     {
         var v0 = new uvec4(9u, 9u, 4u, 9u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(7u, 6u, 2u, 9u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(8u, 9u, 2u, 0u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(5u, 5u, 3u, 4u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(0u, 5u, 6u, 4u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(3u, 5u, 4u, 2u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(8u, 4u, 0u, 0u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(4u, 2u, 5u, 7u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(3u, 0u, 1u, 3u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new uvec4(0u, 9u, 7u, 9u);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
 }
Esempio n. 12
0
 public void InvariantId()
 {
     {
         var v0 = new uvec4(6u, 8u, 0u, 8u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(9u, 9u, 3u, 6u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(7u, 7u, 1u, 1u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(9u, 6u, 7u, 5u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(9u, 6u, 4u, 9u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(1u, 8u, 2u, 7u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(8u, 0u, 1u, 5u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(0u, 5u, 8u, 4u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(7u, 0u, 2u, 2u);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new uvec4(5u, 1u, 8u, 0u);
         Assert.AreEqual(v0, +v0);
     }
 }
Esempio n. 13
0
 public void InvariantTriple()
 {
     {
         var v0 = new uvec4(5u, 9u, 5u, 1u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(1u, 0u, 1u, 8u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(8u, 6u, 6u, 5u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(9u, 0u, 7u, 3u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(7u, 7u, 0u, 6u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(5u, 4u, 2u, 4u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(9u, 7u, 5u, 7u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(7u, 3u, 6u, 7u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(3u, 6u, 0u, 9u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new uvec4(9u, 9u, 5u, 8u);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
 }
Esempio n. 14
0
 public void InvariantDouble()
 {
     {
         var v0 = new uvec4(1u, 9u, 9u, 6u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(5u, 0u, 9u, 3u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(5u, 1u, 7u, 7u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(7u, 6u, 8u, 2u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(7u, 8u, 9u, 0u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(0u, 9u, 1u, 6u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(8u, 7u, 2u, 2u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(6u, 3u, 0u, 4u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(6u, 7u, 1u, 9u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new uvec4(3u, 1u, 2u, 3u);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
 }
Esempio n. 15
0
        public void Indexer()
        {
            var v = new uvec4(2u, 4u, 8u, 2u);

            Assert.AreEqual(2u, v[0]);
            Assert.AreEqual(4u, v[1]);
            Assert.AreEqual(8u, v[2]);
            Assert.AreEqual(2u, v[3]);

            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[4]; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { v[4] = 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[3] = 0u;
            Assert.AreEqual(0u, v[3]);
            v[2] = 1u;
            Assert.AreEqual(1u, v[2]);
            v[3] = 2u;
            Assert.AreEqual(2u, v[3]);
            v[0] = 3u;
            Assert.AreEqual(3u, v[0]);
            v[2] = 4u;
            Assert.AreEqual(4u, v[2]);
            v[1] = 5u;
            Assert.AreEqual(5u, v[1]);
            v[2] = 6u;
            Assert.AreEqual(6u, v[2]);
            v[0] = 7u;
            Assert.AreEqual(7u, v[0]);
            v[0] = 8u;
            Assert.AreEqual(8u, v[0]);
            v[3] = 9u;
            Assert.AreEqual(9u, v[3]);
        }
Esempio n. 16
0
 public void Constructors()
 {
     {
         var v = new uvec4(1u);
         Assert.AreEqual(1u, v.x);
         Assert.AreEqual(1u, v.y);
         Assert.AreEqual(1u, v.z);
         Assert.AreEqual(1u, v.w);
     }
     {
         var v = new uvec4(0u, 2u, 0u, 8u);
         Assert.AreEqual(0u, v.x);
         Assert.AreEqual(2u, v.y);
         Assert.AreEqual(0u, v.z);
         Assert.AreEqual(8u, v.w);
     }
     {
         var v = new uvec4(new uvec2(1u, 5u));
         Assert.AreEqual(1u, v.x);
         Assert.AreEqual(5u, v.y);
         Assert.AreEqual(0u, v.z);
         Assert.AreEqual(0u, v.w);
     }
     {
         var v = new uvec4(new uvec3(0u, 0u, 1u));
         Assert.AreEqual(0u, v.x);
         Assert.AreEqual(0u, v.y);
         Assert.AreEqual(1u, v.z);
         Assert.AreEqual(0u, v.w);
     }
     {
         var v = new uvec4(new uvec4(2u, 6u, 2u, 1u));
         Assert.AreEqual(2u, v.x);
         Assert.AreEqual(6u, v.y);
         Assert.AreEqual(2u, v.z);
         Assert.AreEqual(1u, v.w);
     }
 }
Esempio n. 17
0
 /// <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(uvec4 x, uvec4 y, out uvec4 msb, out uvec4 lsb)
 {
     throw _invalidAccess;
 }
Esempio n. 18
0
 /// <summary>Returns the number of bits set to 1 in the binary representation of value.</summary>
 protected static ivec4 bitCount(uvec4 value)
 {
     throw _invalidAccess;
 }
Esempio n. 19
0
 protected bvec4 notEqual(uvec4 x, uvec4 y)
 {
     throw new NotImplementedException();
 }
Esempio n. 20
0
 protected uvec4 min(uvec4 x, uint y)
 {
     throw new NotImplementedException();
 }
Esempio n. 21
0
 /// <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 uvec4 bitfieldReverse(uvec4 value)
 {
     throw _invalidAccess;
 }
Esempio n. 22
0
 /// <summary>
 /// Returns a bvec4 from component-wise application of Equal (lhs == rhs).
 /// </summary>
 public static bvec4 Equal(uvec4 lhs, uvec4 rhs) => uvec4.Equal(lhs, rhs);
Esempio n. 23
0
 /// <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(uvec4 value)
 {
     throw _invalidAccess;
 }
Esempio n. 24
0
 /// <summary>
 /// OuterProduct treats the first parameter c as a column vector (matrix with one column) and the second parameter r as a row vector (matrix with one row) and does a linear algebraic matrix multiply c * r, yielding a matrix whose number of rows is the number of components in c and whose number of columns is the number of components in r.
 /// </summary>
 public static umat4x3 OuterProduct(uvec3 c, uvec4 r) => uvec3.OuterProduct(c, r);
Esempio n. 25
0
 /// <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 uvec4 usubBorrow(uvec4 x, uvec4 y, out uvec4 borrow)
 {
     throw _invalidAccess;
 }
Esempio n. 26
0
 /// <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 uvec4 bitfieldInsert(uvec4 _base, uvec4 insert, int offset, int bits)
 {
     throw _invalidAccess;
 }
Esempio n. 27
0
 /// <summary>
 /// Returns true iff this equals rhs type- and component-wise.
 /// </summary>
 public static bool Equals(uvec4 v, object obj) => v.Equals(obj);
 /// <summary>Returns y if y &lt; x, otherwise it returns x.</summary>
 protected internal static uvec4 Min(uvec4 x, uint y)
 {
     throw _invalidAccess;
 }
Esempio n. 29
0
 public uvec3(uvec4 xyzw)
 {
     x = xyzw.x;
     y = xyzw.y;
     z = xyzw.z;
 }
Esempio n. 30
0
 /// <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 uvec4 uaddCarry(uvec4 x, uvec4 y, out uvec4 carry)
 {
     throw _invalidAccess;
 }
Esempio n. 31
0
 /// <summary>
 /// Returns a bvec4 from component-wise application of GreaterThanEqual (lhs &gt;= rhs).
 /// </summary>
 public static bvec4 GreaterThanEqual(uvec4 lhs, uvec4 rhs) => uvec4.GreaterThanEqual(lhs, rhs);
Esempio n. 32
0
 /// <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 ivec4 findLSB(uvec4 value)
 {
     throw _invalidAccess;
 }
Esempio n. 33
0
 /// <summary>
 /// Returns true iff this equals rhs component-wise.
 /// </summary>
 public static bool Equals(uvec4 v, uvec4 rhs) => v.Equals(rhs);
Esempio n. 34
0
 protected uvec4 max(uvec4 x, uvec4 y)
 {
     throw new NotImplementedException();
 }
Esempio n. 35
0
 /// <summary>
 /// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs).
 /// </summary>
 public static bvec4 NotEqual(uvec4 lhs, uvec4 rhs) => uvec4.NotEqual(lhs, rhs);
Esempio n. 36
0
 protected uvec4 clamp(uvec4 x, uint minVal, uint maxVal)
 {
     throw new NotImplementedException();
 }
Esempio n. 37
0
 protected bvec4 lessThan(uvec4 x, uvec4 y)
 {
     throw new NotImplementedException();
 }
Esempio n. 38
0
 public void InvariantAssociative()
 {
     {
         var v0 = new uvec4(3u, 2u, 8u, 8u);
         var v1 = new uvec4(8u, 4u, 3u, 6u);
         var v2 = new uvec4(9u, 7u, 1u, 4u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(8u, 7u, 9u, 6u);
         var v1 = new uvec4(9u, 7u, 9u, 6u);
         var v2 = new uvec4(0u, 5u, 3u, 4u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(1u, 5u, 2u, 9u);
         var v1 = new uvec4(3u, 0u, 6u, 0u);
         var v2 = new uvec4(5u, 2u, 9u, 3u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(6u, 0u, 1u, 8u);
         var v1 = new uvec4(7u, 1u, 8u, 4u);
         var v2 = new uvec4(6u, 4u, 5u, 7u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(8u, 8u, 9u, 5u);
         var v1 = new uvec4(3u, 0u, 2u, 7u);
         var v2 = new uvec4(8u, 4u, 7u, 3u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(2u, 3u, 2u, 8u);
         var v1 = new uvec4(0u, 1u, 8u, 6u);
         var v2 = new uvec4(7u, 6u, 9u, 8u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(6u, 1u, 8u, 9u);
         var v1 = new uvec4(7u, 8u, 8u, 7u);
         var v2 = new uvec4(9u, 5u, 1u, 5u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(1u, 0u, 6u, 4u);
         var v1 = new uvec4(0u, 1u, 4u, 2u);
         var v2 = new uvec4(3u, 7u, 5u, 3u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(8u, 9u, 4u, 4u);
         var v1 = new uvec4(5u, 9u, 9u, 1u);
         var v2 = new uvec4(8u, 0u, 9u, 2u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
     {
         var v0 = new uvec4(2u, 2u, 9u, 9u);
         var v1 = new uvec4(6u, 9u, 3u, 7u);
         var v2 = new uvec4(1u, 6u, 7u, 9u);
         Assert.AreEqual(v0 * (v1 + v2), v0 * v1 + v0 * v2);
     }
 }
Esempio n. 39
0
 protected bvec4 greaterThanEqual(uvec4 x, uvec4 y)
 {
     throw new NotImplementedException();
 }
 /// <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 vec4 uintBitsToFloat(uvec4 value)
 {
     throw _invalidAccess;
 }
Esempio n. 41
0
 /// <summary>
 /// Returns a hash code for this instance.
 /// </summary>
 public static int GetHashCode(uvec4 v) => v.GetHashCode();
 /// <summary>Returns Min (Max (x, minVal), maxVal). Results are undefined if minVal > maxVal.</summary>
 protected internal static uvec4 Clamp(uvec4 x, uvec4 minVal, uvec4 maxVal)
 {
     throw _invalidAccess;
 }
 /// <summary>Returns y if x &lt; y, otherwise it returns x.</summary>
 protected internal static uvec4 Max(uvec4 x, uvec4 y)
 {
     throw _invalidAccess;
 }
 /// <summary>
 /// </summary>
 /// <param name="uniformName"></param>
 /// <param name="values"></param>
 /// <returns></returns>
 public int SetUniform(string uniformName, uvec4[] values)
 {
     int location = GetUniformLocation(uniformName);
     if (location >= 0)
     {
         if (glUniform4uiv == null) { glUniform4uiv = OpenGL.GetDelegateFor<OpenGL.glUniform4uiv>(); }
         int count = values.Length;
         var value = new uint[count * 4];
         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;
             value[index++] = values[i].w;
         }
         glUniform4uiv(location, count, value);
     }
     return location;
 }
Esempio n. 45
0
 /// <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 uvec4 bitfieldExtract(uvec4 value, int offset, int bits)
 {
     throw _invalidAccess;
 }