Пример #1
0
        public void testClear()
        {
            IndexData indexData = new IndexData();

            indexData.AddTriangle(1, 2, 4);
            indexData.Clear();

            Assert.AreEqual(0, indexData.NumIndices);
            Assert.IsTrue(indexData.UseQuadLayout);
        }
Пример #2
0
        private void GenerateIndices()
        {
            List <StaticVertex> tempVertices = new List <StaticVertex>();
            List <int>          tempIndices  = new List <int>();

            foreach (StaticVertex v in VertexData)
            {
                //verifica se esiste un vertice già nella lista
                int  i     = 0;
                bool found = false;
                foreach (StaticVertex v2 in tempVertices)
                {
                    if (StaticVertex.Compare(v, v2))
                    {
                        //travato
                        found = true;
                        break;
                    }
                    i++;
                }

                if (found)
                {
                    tempIndices.Add(i);
                    StaticVertex v2 = tempVertices[i];
                    //somma le normali
                }
                else
                {
                    i = tempVertices.Count;
                    tempVertices.Add(v);
                    tempIndices.Add(i);
                }

                //normali
                StaticVertex vTemp = tempVertices[i];
                vTemp.Normal   += v.Normal;
                tempVertices[i] = vTemp;
            }


            //normalizzazione finale
            VertexData.Clear();
            //foreach (VertexFormat v in tempVertices)
            //{
            //    v.Normal.Normalize();
            //    Vertices.Add(v);
            //}
            VertexData.AddRange(tempVertices);

            IndexData.Clear();
            IndexData.AddRange(tempIndices);
        }
Пример #3
0
 public void Clear()
 {
     IndexData.Clear();
     StoredData.Clear();
 }
Пример #4
0
 public override void Dispose()
 {
     _vertexData.Clear();
     _indexData.Clear();
     base.Dispose();
 }
Пример #5
0
        public void testCopyTo()
        {
            // arbitrary data -> arbitrary data
            var source = new IndexData();

            source.AddTriangle(1, 2, 3);
            source.AddTriangle(4, 5, 6);

            var target = new IndexData();

            target.AddTriangle(7, 8, 9);
            source.CopyTo(target, 0, 0, 3, 3);

            Assert.AreEqual(3, target.NumIndices);
            Assert.AreEqual(4, target.GetIndex(0));
            Assert.AreEqual(5, target.GetIndex(1));
            Assert.AreEqual(6, target.GetIndex(2));

            source.CopyTo(target, 3);
            Assert.AreEqual(9, target.NumIndices);

            // quad data -> quad data
            source.Clear();
            target.Clear();

            source.AddTriangle(0, 1, 2);
            target.AddQuad(0, 1, 2, 3);
            source.CopyTo(target, 6, 4);

            Assert.IsTrue(target.UseQuadLayout);
            Assert.AreEqual(9, target.NumIndices);
            Assert.AreEqual(2, target.GetIndex(5));
            Assert.AreEqual(4, target.GetIndex(6));
            Assert.AreEqual(5, target.GetIndex(7));
            Assert.AreEqual(6, target.GetIndex(8));

            // quad data -> arbitrary data
            target.Clear();
            target.AddQuad(1, 2, 3, 4);
            source.CopyTo(target, 6, 4);

            Assert.IsTrue(source.UseQuadLayout);
            Assert.IsFalse(target.UseQuadLayout);
            Assert.AreEqual(9, target.NumIndices);
            Assert.AreEqual(3, target.GetIndex(5));
            Assert.AreEqual(4, target.GetIndex(6));
            Assert.AreEqual(5, target.GetIndex(7));
            Assert.AreEqual(6, target.GetIndex(8));

            // arbitrary data -> quad data
            source.Clear();
            source.AddTriangle(1, 2, 3);
            target.Clear();
            target.AddQuad(0, 1, 2, 3);
            source.CopyTo(target, 6, 4);

            Assert.IsFalse(source.UseQuadLayout);
            Assert.IsFalse(target.UseQuadLayout);
            Assert.AreEqual(9, target.NumIndices);
            Assert.AreEqual(2, target.GetIndex(5));
            Assert.AreEqual(5, target.GetIndex(6));
            Assert.AreEqual(6, target.GetIndex(7));
            Assert.AreEqual(7, target.GetIndex(8));
        }