Esempio n. 1
0
        protected virtual void SetupVertices()
        {
            Texture    texture    = Style.Texture;
            VertexData vertexData = VertexData;
            IndexData  indexData  = IndexData;

            indexData.NumIndices = 0;
            indexData.AddQuad(0, 1, 2, 3);

            if (vertexData.NumVertices != 4)
            {
                vertexData.NumVertices = 4;
            }

            if (Texture != null)
            {
                texture.SetupVertexPositions(vertexData, 0, _bounds);
                texture.SetupTextureCoordinates(vertexData);
            }
            else
            {
                vertexData.SetPoint(0, _bounds.Left, _bounds.Top);
                vertexData.SetPoint(1, _bounds.Right, _bounds.Top);
                vertexData.SetPoint(2, _bounds.Left, _bounds.Bottom);
                vertexData.SetPoint(3, _bounds.Right, _bounds.Bottom);

                vertexData.SetTexCoords(0, 0.0f, 0.0f);
                vertexData.SetTexCoords(1, 1.0f, 0.0f);
                vertexData.SetTexCoords(2, 0.0f, 1.0f);
                vertexData.SetTexCoords(3, 1.0f, 1.0f);
            }

            SetRequiresRedraw();
        }
Esempio n. 2
0
        public FilterQuad(TextureSmoothing smoothing) : base(new VertexData(4), new IndexData())
        {
            IndexData.AddQuad(0, 1, 2, 3);
            VertexData.Colorize(0xFFFFFF, 1.0f);

            TextureSmoothing = smoothing;
            PixelSnapping    = false;
        }
Esempio n. 3
0
        public void testAppendQuad()
        {
            var indexData = new IndexData();

            // basic quad data

            indexData.AddQuad(0, 1, 2, 3);
            indexData.AddQuad(4, 5, 6, 7);

            Assert.IsTrue(indexData.UseQuadLayout);
            Assert.AreEqual(2, indexData.NumQuads);
            Assert.AreEqual(4, indexData.NumTriangles);
            Assert.AreEqual(12, indexData.NumIndices);

            Assert.AreEqual(0, indexData.GetIndex(0));
            Assert.AreEqual(1, indexData.GetIndex(1));
            Assert.AreEqual(2, indexData.GetIndex(2));
            Assert.AreEqual(1, indexData.GetIndex(3));
            Assert.AreEqual(3, indexData.GetIndex(4));
            Assert.AreEqual(2, indexData.GetIndex(5));
            Assert.AreEqual(4, indexData.GetIndex(6));
            Assert.AreEqual(5, indexData.GetIndex(7));
            Assert.AreEqual(6, indexData.GetIndex(8));
            Assert.AreEqual(5, indexData.GetIndex(9));
            Assert.AreEqual(7, indexData.GetIndex(10));
            Assert.AreEqual(6, indexData.GetIndex(11));

            indexData.NumTriangles = 0;
            Assert.AreEqual(0, indexData.NumIndices);
            Assert.AreEqual(0, indexData.NumQuads);

            // arbitrary data
            indexData.AddQuad(0, 1, 3, 2);
            Assert.IsFalse(indexData.UseQuadLayout);
            Assert.AreEqual(1, indexData.NumQuads);
            Assert.AreEqual(2, indexData.NumTriangles);
            Assert.AreEqual(6, indexData.NumIndices);

            Assert.AreEqual(0, indexData.GetIndex(0));
            Assert.AreEqual(1, indexData.GetIndex(1));
            Assert.AreEqual(3, indexData.GetIndex(2));
            Assert.AreEqual(1, indexData.GetIndex(3));
            Assert.AreEqual(2, indexData.GetIndex(4));
            Assert.AreEqual(3, indexData.GetIndex(5));
        }
Esempio n. 4
0
        public void TestTexCoords()
        {
            Texture rootTexture = new MockTexture(100, 100);
            Texture subTexture  = Texture.FromTexture(rootTexture, Rectangle.Create(50, 50, 50, 50));

            VertexData vertexData = new VertexData();

            vertexData.SetPoint(0, 0, 0);
            vertexData.SetPoint(1, 1, 0);
            vertexData.SetPoint(2, 0, 1);
            vertexData.SetPoint(3, 1, 1);
            vertexData.SetTexCoords(0, 0, 0);
            vertexData.SetTexCoords(1, 1, 0);
            vertexData.SetTexCoords(2, 0, 1);
            vertexData.SetTexCoords(3, 1, 1);

            IndexData indexData = new IndexData();

            indexData.AddQuad(0, 1, 2, 3);

            Mesh mesh = new Mesh(vertexData, indexData);

            ComparePoints(Point.Create(0, 0), mesh.GetTexCoords(0));
            ComparePoints(Point.Create(1, 1), mesh.GetTexCoords(3));

            mesh.Texture = subTexture; // should change internal texture coordinates

            ComparePoints(Point.Create(0, 0), mesh.GetTexCoords(0));
            ComparePoints(Point.Create(1, 1), mesh.GetTexCoords(3));

            ComparePoints(Point.Create(0.5f, 0.5f), vertexData.GetTexCoords(0));
            ComparePoints(Point.Create(1.0f, 1.0f), vertexData.GetTexCoords(3));

            mesh.SetTexCoords(2, 0.25f, 0.75f);

            ComparePoints(Point.Create(0.25f, 0.75f), mesh.GetTexCoords(2));
            ComparePoints(Point.Create(0.625f, 0.875f), vertexData.GetTexCoords(2));

            mesh.Texture = rootTexture;

            ComparePoints(Point.Create(0f, 0f), mesh.GetTexCoords(0));
            ComparePoints(Point.Create(1f, 1f), mesh.GetTexCoords(3));

            ComparePoints(Point.Create(0f, 0f), vertexData.GetTexCoords(0));
            ComparePoints(Point.Create(1f, 1f), vertexData.GetTexCoords(3));
            ComparePoints(Point.Create(0.25f, 0.75f), vertexData.GetTexCoords(2));
        }
Esempio n. 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));
        }