Ejemplo n.º 1
0
        public static void SetRegionData(ivec4 region, int[] data, int stride)
        {
            var x      = region.x;
            var y      = region.y;
            var width  = region.width;
            var height = region.height;

            Debug.Assert(x > 0);
            Debug.Assert(y > 0);
            Debug.Assert(x < (m_nWidth - 1));
            Debug.Assert((x + width) <= (m_nWidth - 1));
            Debug.Assert(y < (m_nHeight - 1));
            Debug.Assert((y + height) <= (m_nHeight - 1));

            var depth = m_nDepth;

            for (int i = 0; i < height; ++i)
            {
                for (int j = 0; j < width; j++)
                {
                    var b = (byte)((data[i * stride + j] & 0xFF0000) >> 16);
                    m_pData[((y + i) * m_nWidth + x) + j] = b << 24 | b << 16 | b << 8 | b;
                }
                //    Array.Copy(data, (i * stride), m_pData, ((y + i) * m_nWidth + x), width);
                //                Buffer.BlockCopy(data, (i * stride), m_pData, ((y + i) * m_nWidth + x) * depth, width * depth);
            }
        }
Ejemplo n.º 2
0
        public void Indexer()
        {
            var v = new ivec4(9, -7, -3, -9);

            Assert.AreEqual(9, v[0]);
            Assert.AreEqual(-7, v[1]);
            Assert.AreEqual(-3, v[2]);
            Assert.AreEqual(-9, v[3]);

            Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[-2147483648]; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { v[-2147483648] = 0; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[-1]; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { v[-1] = 0; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[4]; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { v[4] = 0; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[2147483647]; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { v[2147483647] = 0; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[5]; });
            Assert.Throws <ArgumentOutOfRangeException>(() => { v[5] = 0; });

            v[3] = 0;
            Assert.AreEqual(0, v[3]);
            v[2] = 1;
            Assert.AreEqual(1, v[2]);
            v[1] = 2;
            Assert.AreEqual(2, v[1]);
            v[3] = 3;
            Assert.AreEqual(3, v[3]);
            v[1] = 4;
            Assert.AreEqual(4, v[1]);
            v[0] = 5;
            Assert.AreEqual(5, v[0]);
            v[1] = 6;
            Assert.AreEqual(6, v[1]);
            v[2] = 7;
            Assert.AreEqual(7, v[2]);
            v[1] = 8;
            Assert.AreEqual(8, v[1]);
            v[1] = 9;
            Assert.AreEqual(9, v[1]);
            v[2] = -1;
            Assert.AreEqual(-1, v[2]);
            v[1] = -2;
            Assert.AreEqual(-2, v[1]);
            v[0] = -3;
            Assert.AreEqual(-3, v[0]);
            v[1] = -4;
            Assert.AreEqual(-4, v[1]);
            v[1] = -5;
            Assert.AreEqual(-5, v[1]);
            v[0] = -6;
            Assert.AreEqual(-6, v[0]);
            v[3] = -7;
            Assert.AreEqual(-7, v[3]);
            v[2] = -8;
            Assert.AreEqual(-8, v[2]);
            v[1] = -9;
            Assert.AreEqual(-9, v[1]);
        }
Ejemplo n.º 3
0
        public void PropertyValues()
        {
            var v    = new ivec4(-7, -5, -7, -3);
            var vals = v.Values;

            Assert.AreEqual(-7, vals[0]);
            Assert.AreEqual(-5, vals[1]);
            Assert.AreEqual(-7, vals[2]);
            Assert.AreEqual(-3, vals[3]);
            Assert.That(vals.SequenceEqual(v.ToArray()));
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
 /// </summary>
 public imat2x4(ivec4 c0, ivec4 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;
 }
Ejemplo n.º 5
0
        public void SerializationJson()
        {
            var v0 = new ivec4(-8, -1, 6, -1);
            var s0 = JsonConvert.SerializeObject(v0);

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

            Assert.AreEqual(v0, v1);
            Assert.AreEqual(s0, s1);
        }
Ejemplo n.º 6
0
 public void InvariantCommutative()
 {
     {
         var v0 = new ivec4(-2, -3, 4, 2);
         var v1 = new ivec4(2, 0, 4, 0);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(7, -6, 5, -4);
         var v1 = new ivec4(-4, -4, -1, -5);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(8, 5, -2, 0);
         var v1 = new ivec4(2, 2, -1, -3);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(-3, 1, -2, -3);
         var v1 = new ivec4(-2, 4, -9, -4);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(6, 6, 7, 0);
         var v1 = new ivec4(-4, -5, 5, -6);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(-8, -4, 8, -1);
         var v1 = new ivec4(-7, -5, -4, 6);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(-5, -8, -6, 6);
         var v1 = new ivec4(0, 2, -9, 9);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(1, -2, 9, 1);
         var v1 = new ivec4(8, -1, 8, 2);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(-7, -2, 6, 6);
         var v1 = new ivec4(5, -1, 1, -3);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
     {
         var v0 = new ivec4(0, -6, 1, 7);
         var v1 = new ivec4(-3, 0, -5, -7);
         Assert.AreEqual(v0 * v1, v1 * v0);
     }
 }
Ejemplo n.º 7
0
 public void InvariantCommutativeNeg()
 {
     {
         var v0 = new ivec4(3, -6, 6, 4);
         var v1 = new ivec4(4, 1, -4, 4);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(4, 6, 3, -5);
         var v1 = new ivec4(9, -1, 1, -3);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(-2, 3, -2, 2);
         var v1 = new ivec4(-2, -6, -6, 2);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(5, 1, 7, 3);
         var v1 = new ivec4(1, -3, -7, 9);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(4, -3, -1, -8);
         var v1 = new ivec4(-2, -4, -8, -2);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(-4, -1, 3, 0);
         var v1 = new ivec4(-7, -3, -2, 3);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(1, -5, -6, -7);
         var v1 = new ivec4(9, 4, -1, 6);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(0, 3, -9, 3);
         var v1 = new ivec4(-4, -1, 2, -2);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(9, -4, -1, -6);
         var v1 = new ivec4(-9, 3, 0, -8);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
     {
         var v0 = new ivec4(4, 0, 7, 0);
         var v1 = new ivec4(-2, -5, 5, -3);
         Assert.AreEqual(v0 - v1, -(v1 - v0));
     }
 }
Ejemplo n.º 8
0
 public void TriangleInequality()
 {
     {
         var v0 = new ivec4(-4, 7, 2, 7);
         var v1 = new ivec4(5, 4, 9, 1);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(-2, 0, 1, -2);
         var v1 = new ivec4(2, -1, 5, -5);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(2, 7, -7, 1);
         var v1 = new ivec4(-6, -6, 9, -1);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(8, 6, 4, 0);
         var v1 = new ivec4(0, 8, -8, -5);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(-3, -3, -6, -8);
         var v1 = new ivec4(2, -2, 1, -5);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(-3, -5, 9, 7);
         var v1 = new ivec4(-6, 4, -5, 1);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(-3, 0, -3, -1);
         var v1 = new ivec4(-4, -5, -2, -8);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(-7, -2, -8, -9);
         var v1 = new ivec4(-9, 9, 0, 2);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(2, 6, -8, 9);
         var v1 = new ivec4(-5, 7, -3, 9);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
     {
         var v0 = new ivec4(5, 2, 8, 1);
         var v1 = new ivec4(6, 2, -4, 4);
         Assert.GreaterOrEqual(v0.NormMax + v1.NormMax, (v0 + v1).NormMax);
     }
 }
Ejemplo n.º 9
0
        public void Operators()
        {
            var v1 = new ivec4(2, 5, 1, -8);
            var v2 = new ivec4(2, 5, 1, -8);
            var v3 = new ivec4(-8, 1, 5, 2);

            Assert.That(v1 == new ivec4(v1));
            Assert.That(v2 == new ivec4(v2));
            Assert.That(v3 == new ivec4(v3));
            Assert.That(v1 == v2);
            Assert.That(v1 != v3);
            Assert.That(v2 != v3);
        }
Ejemplo n.º 10
0
        public void StringInterop()
        {
            var v = new ivec4(8, 0, 3, -7);

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

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

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

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

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

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

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

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

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

            Assert.That(b4);
            Assert.AreEqual(v, v4);
        }
Ejemplo n.º 11
0
 /// <summary>
 /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
 /// </summary>
 public imat3x4(ivec4 c0, ivec4 c1, ivec4 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;
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Constructs this matrix from a series of column vectors. Non-overwritten fields are from an Identity matrix.
 /// </summary>
 public imat3x4(ivec4 c0, ivec4 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 = 0;
     this.m21 = 0;
     this.m22 = 1;
     this.m23 = 0;
 }
Ejemplo n.º 13
0
 public void InvariantTriple()
 {
     {
         var v0 = new ivec4(3, 7, -8, 0);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(-3, 5, 3, -9);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(3, -5, 3, 1);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(9, 0, 3, 2);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(-7, -1, -1, -6);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(6, -6, -9, -5);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(-4, -9, 4, -4);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(-2, 0, -4, 6);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(-2, 2, 6, -8);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
     {
         var v0 = new ivec4(3, 4, -1, 6);
         Assert.AreEqual(v0 + v0 + v0, 3 * v0);
     }
 }
Ejemplo n.º 14
0
 public void InvariantId()
 {
     {
         var v0 = new ivec4(-1, -4, -9, -2);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(-7, -5, -7, 4);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(6, -2, -3, -2);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(9, 4, -3, 5);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(-2, 4, -5, -2);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(8, -7, -6, -6);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(9, -1, 8, -8);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(5, 0, 5, -6);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(5, 2, -2, -9);
         Assert.AreEqual(v0, +v0);
     }
     {
         var v0 = new ivec4(1, 9, -4, -3);
         Assert.AreEqual(v0, +v0);
     }
 }
Ejemplo n.º 15
0
 public void InvariantDouble()
 {
     {
         var v0 = new ivec4(-1, 7, 8, 9);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(5, 5, 8, 8);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(9, 5, 2, -8);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(-4, 7, 1, 5);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(-8, 9, -2, 8);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(-7, 5, 1, -2);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(-5, -9, 9, 2);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(-4, 0, 4, -1);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(4, 1, 4, -8);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
     {
         var v0 = new ivec4(-5, 1, -8, -6);
         Assert.AreEqual(v0 + v0, 2 * v0);
     }
 }
Ejemplo n.º 16
0
 public void InvariantIdNeg()
 {
     {
         var v0 = new ivec4(6, 7, -4, 7);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-3, 2, -1, 8);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-8, -9, -7, -4);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-8, -3, -2, 0);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-7, -1, 0, 6);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-3, 5, -2, -1);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-4, 3, 7, 2);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-2, -3, 8, 6);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(2, 2, -4, 8);
         Assert.AreEqual(v0, -(-v0));
     }
     {
         var v0 = new ivec4(-6, 4, -8, -6);
         Assert.AreEqual(v0, -(-v0));
     }
 }
Ejemplo n.º 17
0
 public void InvariantNorm()
 {
     {
         var v0 = new ivec4(4, -1, -2, -1);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(2, 0, -8, -9);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(4, 8, -1, -3);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(-8, 6, 0, 8);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(-1, 7, 9, 2);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(4, 2, -3, 6);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(9, 4, -2, 8);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(-8, 5, -2, -2);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(-5, 1, -5, -9);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
     {
         var v0 = new ivec4(-1, -4, -7, -7);
         Assert.LessOrEqual(v0.NormMax, v0.Norm);
     }
 }
Ejemplo n.º 18
0
 public void Constructors()
 {
     {
         var v = new ivec4(9);
         Assert.AreEqual(9, v.x);
         Assert.AreEqual(9, v.y);
         Assert.AreEqual(9, v.z);
         Assert.AreEqual(9, v.w);
     }
     {
         var v = new ivec4(5, 4, 2, 0);
         Assert.AreEqual(5, v.x);
         Assert.AreEqual(4, v.y);
         Assert.AreEqual(2, v.z);
         Assert.AreEqual(0, v.w);
     }
     {
         var v = new ivec4(new ivec2(2, -6));
         Assert.AreEqual(2, v.x);
         Assert.AreEqual(-6, v.y);
         Assert.AreEqual(0, v.z);
         Assert.AreEqual(0, v.w);
     }
     {
         var v = new ivec4(new ivec3(-5, -9, 6));
         Assert.AreEqual(-5, v.x);
         Assert.AreEqual(-9, v.y);
         Assert.AreEqual(6, v.z);
         Assert.AreEqual(0, v.w);
     }
     {
         var v = new ivec4(new ivec4(-1, -9, 3, -7));
         Assert.AreEqual(-1, v.x);
         Assert.AreEqual(-9, v.y);
         Assert.AreEqual(3, v.z);
         Assert.AreEqual(-7, v.w);
     }
 }
 /// <summary>Returns Min (Max (x, minVal), maxVal). Results are undefined if minVal > maxVal.</summary>
 protected internal static ivec4 Clamp(ivec4 x, ivec4 minVal, ivec4 maxVal)
 {
     throw _invalidAccess;
 }
 /// <summary>Returns 1.0 if x &gt; 0, 0.0 if x = 0, or –1.0 if x &lt; 0.</summary>
 /// <returns>The sign of x</returns>
 protected static ivec4 sign(ivec4 x)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 21
0
 /// <summary>
 /// Returns true iff this equals rhs type- and component-wise.
 /// </summary>
 public static bool Equals(ivec4 v, object obj) => v.Equals(obj);
Ejemplo n.º 22
0
 /// <summary>
 /// Returns the number of components (4).
 /// </summary>
 public static int Count(ivec4 v) => v.Count;
Ejemplo n.º 23
0
 /// <summary>
 /// Returns a string representation of this vector using a provided seperator and a format for each component.
 /// </summary>
 public static string ToString(ivec4 v, string sep, string format) => v.ToString(sep, format);
Ejemplo n.º 24
0
 public ivec3(ivec4 xyzw)
 {
     x = xyzw.x;
     y = xyzw.y;
     z = xyzw.z;
 }
Ejemplo n.º 25
0
        public static ivec4 AllocateRegion(int width, int height)
        {
            ivec3 node, prev;
            ivec4 region = new ivec4() { x = 0, y = 0, width = width, height = height };
            int i;

            int bestHeight = int.MaxValue;
            int bestIndex = -1;
            int bestWidth = int.MaxValue;

            for (i = 0; i < m_pNodes.Count; ++i)
            {
                int y = Fit(i, width, height);

                if (y >= 0)
                {
                    node = m_pNodes[i];
                    if (((y + height) < bestHeight) || (((y + height) == bestHeight) && (node.z < bestWidth)))
                    {
                        bestHeight = y + height;
                        bestIndex = i;
                        bestWidth = node.z;
                        region.x = node.x;
                        region.y = y;
                    }
                }
            }

            if (bestIndex == -1)
            {
                region.x = -1;
                region.y = -1;
                region.width = 0;
                region.height = 0;
                return region;
            }

            //New node
            node.x = region.x;
            node.y = region.y + height;
            node.z = width;
            m_pNodes.Insert(bestIndex, node);

            for (i = bestIndex + 1; i < m_pNodes.Count; ++i)
            {
                node = m_pNodes[i];
                prev = m_pNodes[i - 1];

                if (node.x < (prev.x + prev.z))
                {
                    int shrink = prev.x + prev.z - node.x;
                    node.x += shrink;
                    node.z -= shrink;
                    if (node.z <= 0)
                    {
                        m_pNodes.RemoveAt(i);
                        --i;
                    }
                    else
                    {
                        m_pNodes[i] = node;
                        break;
                    }
                }
                else
                {
                    break;
                }
            }

            Merge();

            m_nUsed += width * height;

            return region;
        }
Ejemplo n.º 26
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 ivec4 bitfieldReverse(ivec4 value)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 27
0
 /// <summary>Returns the number of bits set to 1 in the binary representation of value.</summary>
 protected static ivec4 bitCount(ivec4 value)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 28
0
 /// <summary>
 /// Returns the bit number of the most significant bit in the binary representation of value.
 /// For positive integers, the result will be the bit number of the most significant bit set to 1.
 /// For negative integers, the result will be the bit number of the most significant bit set to 0. 
 /// For a value of zero or negative one, -1 will be returned.
 /// </summary>
 protected static ivec4 findMSB(ivec4 value)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 29
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 imulExtended(ivec4 x, ivec4 y, out ivec4 msb, out ivec4 lsb)
 {
     throw _invalidAccess;
 }
 /// <summary>Returns x if x >= 0, otherwise it returns –x.</summary>
 /// <returns>The absolute value of x</returns>
 protected internal static ivec4 Abs(ivec4 x)
 {
     throw _invalidAccess;
 }
 /// <summary>Returns y if x &lt; y, otherwise it returns x.</summary>
 protected internal static ivec4 Max(ivec4 x, ivec4 y)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 32
0
 /// <summary>
 /// Returns a ivec4 with independent and identically distributed uniform integer values between minValue (inclusive) and maxValue (exclusive). (minValue == maxValue is allowed and returns minValue. Negative values are allowed.)
 /// </summary>
 public static ivec4 RandomUniform(Random random, ivec4 minValue, ivec4 maxValue) => ivec4.RandomUniform(random, minValue, maxValue);
Ejemplo n.º 33
0
        public static void SetRegionData(ivec4 region, int[] data, int stride)
        {
            var x = region.x;
            var y = region.y;
            var width = region.width;
            var height = region.height;

            Debug.Assert(x > 0);
            Debug.Assert(y > 0);
            Debug.Assert(x < (m_nWidth - 1));
            Debug.Assert((x + width) <= (m_nWidth - 1));
            Debug.Assert(y < (m_nHeight - 1));
            Debug.Assert((y + height) <= (m_nHeight - 1));

            var depth = m_nDepth;
            for (int i = 0; i < height; ++i)
            {
                for (int j = 0; j < width; j++)
                {
                    var b = (byte)((data[i * stride + j] & 0xFF0000) >> 16);
                    m_pData[((y + i) * m_nWidth + x) + j] = b << 24 | b << 16 | b << 8 | b;
                }
                //    Array.Copy(data, (i * stride), m_pData, ((y + i) * m_nWidth + x), width);
                //                Buffer.BlockCopy(data, (i * stride), m_pData, ((y + i) * m_nWidth + x) * depth, width * depth);
            }
        }
Ejemplo n.º 34
0
 /// <summary>
 /// Returns a bvec4 from component-wise application of Equal (lhs == rhs).
 /// </summary>
 public static bvec4 Equal(ivec4 lhs, ivec4 rhs) => ivec4.Equal(lhs, rhs);
Ejemplo n.º 35
0
 /// <summary>
 /// </summary>
 /// <param name="uniformName"></param>
 /// <param name="values"></param>
 /// <returns></returns>
 public int SetUniform(string uniformName, ivec4[] values)
 {
     int location = GetUniformLocation(uniformName);
     if (location >= 0)
     {
         if (glUniform4iv == null) { glUniform4iv = OpenGL.GetDelegateFor<OpenGL.glUniform4iv>(); }
         int count = values.Length;
         var value = new int[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;
         }
         glUniform4iv(location, count, value);
     }
     return location;
 }
Ejemplo n.º 36
0
 /// <summary>
 /// Returns a bvec4 from component-wise application of GreaterThanEqual (lhs &gt;= rhs).
 /// </summary>
 public static bvec4 GreaterThanEqual(ivec4 lhs, ivec4 rhs) => ivec4.GreaterThanEqual(lhs, rhs);
Ejemplo n.º 37
0
 /// <summary>
 /// Returns a string representation of this vector using a provided seperator.
 /// </summary>
 public static string ToString(ivec4 v, string sep) => v.ToString(sep);
Ejemplo n.º 38
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 ivec4 bitfieldInsert(ivec4 _base, ivec4 insert, int offset, int bits)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 39
0
 /// <summary>
 /// Returns a string representation of this vector using a provided seperator and a format and format provider for each component.
 /// </summary>
 public static string ToString(ivec4 v, string sep, string format, IFormatProvider provider) => v.ToString(sep, format, provider);
 /// <summary>
 /// Splits x into a floating-point significand in the range [0.5, 1.0) 
 /// and an integral exponent of two, such that: x=significand⋅2**exponent
 /// The significand is returned by the function and the exponent is returned in the parameter exp. 
 /// For a floating-point value of zero, the significant and exponent are both zero. 
 /// For a floating-point value that is an infinity or is not a number, the results are undefined.
 /// </summary>
 protected static dvec4 frexp(dvec4 x, out ivec4 exp)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 41
0
 /// <summary>
 /// Returns true iff this equals rhs component-wise.
 /// </summary>
 public static bool Equals(ivec4 v, ivec4 rhs) => v.Equals(rhs);
 /// <summary>
 /// Returns a floating-point value corresponding to a signed 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 intBitsToFloat(ivec4 value)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 43
0
 /// <summary>
 /// Returns a hash code for this instance.
 /// </summary>
 public static int GetHashCode(ivec4 v) => v.GetHashCode();
 /// <summary>
 /// Builds a floating-point number from x and the corresponding integral exponent of two in exp, 
 /// returning: significand⋅2*+exponent
 /// If this product is too large to be represented in the floating-point type, the result is undefined.
 /// </summary>
 protected static dvec4 ldexp(dvec4 x, ivec4 exp)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 45
0
 /// <summary>
 /// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs).
 /// </summary>
 public static bvec4 NotEqual(ivec4 lhs, ivec4 rhs) => ivec4.NotEqual(lhs, rhs);
 /// <summary>Returns y if y &lt; x, otherwise it returns x.</summary>
 protected internal static ivec4 Min(ivec4 x, int y)
 {
     throw _invalidAccess;
 }
Ejemplo n.º 47
0
        /*
         * private static Dictionary<string, Mesh> ParseGroupedMeshes(string[] lines)
         * {
         *      var map = new Dictionary<string, Mesh>();
         *      var index = 0;
         *
         *      Mesh mesh;
         *
         *      while ((mesh = ParseMesh(lines, ref index, out var name)) != null)
         *      {
         *              map.Add(name, mesh);
         *      }
         *
         *      return map;
         * }
         *
         * private static Mesh ParseMesh(string[] lines, ref int index, out string name)
         * {
         *      // This means that the end of the file was reached.
         *      if (index >= lines.Length - 1 || lines[index].Length == 0)
         *      {
         *              name = null;
         *
         *              return null;
         *      }
         *
         *      string line = lines[index];
         *
         *      while (!(line.StartsWith("o ") || line.StartsWith("g ")))
         *      {
         *              line = lines[++index];
         *      }
         *
         *      name = line.Split(' ')[1];
         *
         *      // Custom object names often end with "_[Shape].XYZ", such as "Box_Cube.001". In those cases, the user-set
         *      // name is just the first portion. The last underscore index is used in case the object name itself
         *      // contains underscores.
         *      var underscoreIndex = name.LastIndexOf("_", StringComparison.CurrentCulture);
         *
         *      if (underscoreIndex > 0)
         *      {
         *              name = name.Substring(0, underscoreIndex);
         *      }
         *
         *      var points = new List<vec3>();
         *      var source = new List<vec2>();
         *      var normals = new List<vec3>();
         *
         *      // Parse points.
         *      do
         *      {
         *              line = lines[++index];
         *
         *              if (line.StartsWith("v "))
         *              {
         *                      points.Add(ParseVec3(line));
         *              }
         *      }
         *      while (line.StartsWith("v "));
         *
         *      // Parse textures.
         *      do
         *      {
         *              line = lines[++index];
         *
         *              if (line.StartsWith("vt"))
         *              {
         *                      source.Add(ParseVec2(line));
         *              }
         *      }
         *      while (line.StartsWith("vt"));
         *
         *      // If the exported mesh is untextured, a default grey texture is used.
         *      if (source.Count == 0)
         *      {
         *              source.Add(vec2.Zero);
         *      }
         *
         *      // Parse normals.
         *      do
         *      {
         *              line = lines[++index];
         *
         *              if (line.StartsWith("vn"))
         *              {
         *                      points.Add(ParseVec3(line));
         *              }
         *      }
         *      while (line.StartsWith("vn"));
         *
         *      // Advance to face lines.
         *      //while (!lines[++index].StartsWith("f "))
         *      {
         *      }
         *
         *      var vertices = new List<ivec3>();
         *      var indices = new List<ushort>();
         *
         *      while (index < lines.Length - 1 && (line = lines[index]).StartsWith("f "))
         *      {
         *              var tokens = line.Split(' ');
         *
         *              for (int i = 1; i <= 3; i++)
         *              {
         *                      var subTokens = tokens[i].Split('/');
         *
         *                      // TODO: Support textures (using the second sub-token).
         *                      // .obj files use 1-indexing (rather than 0-indexing).
         *                      var pointIndex = int.Parse(subTokens[0]) - 1;
         *                      var normalIndex = int.Parse(subTokens[2]) - 1;
         *                      var vertex = new ivec3(pointIndex, 0, normalIndex);
         *
         *                      int vIndex;
         *
         *                      if ((vIndex = vertices.IndexOf(vertex)) != -1)
         *                      {
         *                              indices.Add((ushort)vIndex);
         *                      }
         *                      else
         *                      {
         *                              indices.Add((ushort)vertices.Count);
         *                              vertices.Add(vertex);
         *                      }
         *              }
         *
         *              index++;
         *      }
         *
         *      // When multiple meshes are present in a Blender scene, vertices are based on absolute position. In order
         *      // to make positioning the mesh easier in-game, points are normalized back to the origin.
         *      var minX = points.Min(p => p.x);
         *      var minY = points.Min(p => p.y);
         *      var minZ = points.Min(p => p.z);
         *
         *      for (int i = 0; i < points.Count; i++)
         *      {
         *              points[i] -= new vec3(minX, minY, minZ);
         *      }
         *
         *      // Same applies to indexes.
         *      var minPointIndex = vertices.Min(v => v.x);
         *      var minNormalIndex = vertices.Min(v => v.z);
         *
         *      for (int i = 0; i < vertices.Count; i++)
         *      {
         *              var v = vertices[i];
         *              v.x -= minPointIndex;
         *              v.z -= minNormalIndex;
         *              vertices[i] = v;
         *      }
         *
         *      // TODO: Load texture (if present in the file).
         *      return new Mesh(points.ToArray(), source.ToArray(), normals.ToArray(), vertices.ToArray(),
         *              indices.ToArray(), null);
         * }
         */

        private static Mesh ParseUngroupedMesh(string filename, string[] lines)
        {
            var points  = lines.Where(l => l.StartsWith("v ")).Select(ParseVec3);
            var normals = lines.Where(l => l.StartsWith("vn")).Select(ParseVec3);
            var sources = lines.Where(l => l.StartsWith("vt")).Select(ParseVec2).ToList();

            // Source coordinates need to be flipped vertically in order to render properly.
            for (int i = 0; i < sources.Count; i++)
            {
                var s = sources[i];
                s.y        = 1 - s.y;
                sources[i] = s;
            }

            bool isUvMapped;

            string[]   textures  = null;
            Material[] materials = null;
            Dictionary <string, int> materialIndexes = null;

            if (sources.Count > 0)
            {
                ParseMaterials(filename, out textures, out materials, out materialIndexes);
                isUvMapped = true;
            }
            // If no material is specified, a default grey texture is used instead.
            else
            {
                sources.Add(vec2.Zero);
                isUvMapped = false;
            }

            var vertices  = new List <ivec4>();
            var indices   = new List <ushort>();
            var lineIndex = 0;

            if (isUvMapped)
            {
                for (int i = 0; i < lines.Length; i++)
                {
                    if (lines[i].StartsWith("usemtl"))
                    {
                        lineIndex = i - 1;

                        break;
                    }
                }
            }
            else
            {
                for (int i = 0; i < lines.Length; i++)
                {
                    if (lines[i].StartsWith("s "))
                    {
                        lineIndex = i;

                        break;
                    }
                }
            }

            // Parse faces (indexes and vertices).
            do
            {
                var name          = lines[lineIndex].Split(' ')[1];
                var materialIndex = isUvMapped ? materialIndexes[name] : 0;

                if (isUvMapped)
                {
                    lineIndex++;
                }

                do
                {
                    var line = lines[++lineIndex];

                    // Smoothing lines can be ignored (since smoothing is implied through vertex order, I think).
                    if (line.StartsWith("s "))
                    {
                        continue;
                    }

                    var tokens = line.Split(' ');

                    for (int i = 1; i <= 3; i++)
                    {
                        var subTokens = tokens[i].Split('/');

                        // .obj files use 1-indexing (rather than 0-indexing).
                        var pointIndex  = int.Parse(subTokens[0]) - 1;
                        var sourceIndex = isUvMapped ? int.Parse(subTokens[1]) - 1 : 0;
                        var normalIndex = int.Parse(subTokens[2]) - 1;
                        var vertex      = new ivec4(pointIndex, sourceIndex, materialIndex, normalIndex);

                        int index;

                        if ((index = vertices.IndexOf(vertex)) != -1)
                        {
                            indices.Add((ushort)index);
                        }
                        else
                        {
                            indices.Add((ushort)vertices.Count);
                            vertices.Add(vertex);
                        }
                    }
                }while (lineIndex < lines.Length - 1 && !lines[lineIndex + 1].StartsWith("usemtl"));
            }while (lineIndex < lines.Length - 1);

            return(new Mesh(points.ToArray(), sources.ToArray(), normals.ToArray(), vertices.ToArray(),
                            indices.ToArray(), textures, materials));
        }
Ejemplo n.º 48
0
 /// <summary>
 /// Extracts bits [offset, offset + bits - 1] from value, returning them 
 /// in the least significant bits of the result.
 /// The most significant bits will be set to the value of bit offset + base – 1.
 /// 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 ivec4 bitfieldExtract(ivec4 value, int offset, int bits)
 {
     throw _invalidAccess;
 }