예제 #1
0
        void CompressDefault <T>(TargetPlatform platform, Color color, int width = 16, int height = 16)
        {
            var context = new TestProcessorContext(platform, "dummy.xnb");

            var processor = new TextureProcessor
            {
                ColorKeyEnabled    = false,
                GenerateMipmaps    = true,
                PremultiplyAlpha   = false,
                ResizeToPowerOfTwo = false,
                TextureFormat      = TextureProcessorOutputFormat.Compressed
            };

            var face = new PixelBitmapContent <Color>(width, height);

            Fill(face, color);
            var input = new Texture2DContent();

            input.Faces[0] = face;

            var output = processor.Process(input, context);

            Assert.NotNull(output);
            Assert.AreEqual(1, output.Faces.Count, "Expected number of faces");
            Assert.AreEqual(5, output.Faces[0].Count, "Expected number of mipmaps");

            Assert.IsAssignableFrom <T>(output.Faces[0][0], "Incorrect pixel format");
        }
예제 #2
0
        void CompressDefault <T>(TargetPlatform platform, Color color)
        {
            var context = new TestProcessorContext(platform, "dummy.xnb");

            var processor = new TextureProcessor
            {
                ColorKeyEnabled    = false,
                GenerateMipmaps    = false,
                PremultiplyAlpha   = false,
                ResizeToPowerOfTwo = false,
                TextureFormat      = TextureProcessorOutputFormat.Compressed
            };

            var face = new PixelBitmapContent <Color>(16, 16);

            Fill(face, color);
            var input = new Texture2DContent();

            input.Faces[0] = face;

            var output = processor.Process(input, context);

            Assert.NotNull(output);
            Assert.AreEqual(1, output.Faces.Count);
            Assert.AreEqual(1, output.Faces[0].Count);

            Assert.IsAssignableFrom <T>(output.Faces[0][0]);
        }
예제 #3
0
        public void MipmapNonSquareNonPowerOfTwo()
        {
            var context = new TestProcessorContext(TargetPlatform.Windows, "dummy.xnb");

            var processor = new TextureProcessor
            {
                ColorKeyEnabled    = false,
                GenerateMipmaps    = true,
                PremultiplyAlpha   = false,
                ResizeToPowerOfTwo = false,
                TextureFormat      = TextureProcessorOutputFormat.Color
            };

            var width  = 23;
            var height = 5;

            var face = new PixelBitmapContent <Color>(width, height);

            Fill(face, Color.Red);
            var input = new Texture2DContent();

            input.Faces[0] = face;

            var output = processor.Process(input, context);

            Assert.NotNull(output);
            Assert.AreEqual(1, output.Faces.Count);

            var outChain = output.Faces[0];

            Assert.AreEqual(5, outChain.Count);

            foreach (var outFace in outChain)
            {
                Assert.AreEqual(width, outFace.Width);
                Assert.AreEqual(height, outFace.Height);

                var bitmap = (PixelBitmapContent <Color>)outFace;
                for (var y = 0; y < height; y++)
                {
                    for (var x = 0; x < width; x++)
                    {
                        Assert.AreEqual(Color.Red, bitmap.GetPixel(x, y));
                    }
                }

                if (width > 1)
                {
                    width /= 2;
                }
                if (height > 1)
                {
                    height /= 2;
                }
            }
        }
예제 #4
0
        public static Effect CompileEffect(GraphicsDevice graphicsDevice, params string[] pathParts)
        {
            var effectProcessor = new EffectProcessor();
            var context         = new TestProcessorContext(TargetPlatform.Windows, "notused.xnb");
            var effectPath      = Paths.Effect(pathParts);
            var compiledEffect  = effectProcessor.Process(new EffectContent
            {
                EffectCode = File.ReadAllText(effectPath),
                Identity   = new ContentIdentity(effectPath)
            }, context);

            return(new Effect(graphicsDevice, compiledEffect.GetEffectCode()));
        }
예제 #5
0
        public static Microsoft.Xna.Framework.Graphics.Effect CompileEffect(GraphicsDevice graphicsDevice, string effectPath)
        {
#if !WINDOWS || DIRECTX || XNA
            var effectProcessor = new EffectProcessor();
            var context         = new TestProcessorContext(TargetPlatform.Windows, "notused.xnb");
            var compiledEffect  = effectProcessor.Process(new EffectContent
            {
                EffectCode = File.ReadAllText(effectPath),
                Identity   = new ContentIdentity(effectPath)
            }, context);

            return(new Microsoft.Xna.Framework.Graphics.Effect(graphicsDevice, compiledEffect.GetEffectCode()));
#else // OpenGL
            throw new NotImplementedException();
#endif
        }
        private void BuildEffect(string effectFile, TargetPlatform targetPlatform, string defines = null)
        {
            var importerContext = new ImporterContext();
            var importer        = new EffectImporter();
            var input           = importer.Import(effectFile, importerContext);

            Assert.NotNull(input);

            var processorContext = new TestProcessorContext(targetPlatform, Path.ChangeExtension(effectFile, ".xnb"));
            var processor        = new EffectProcessor {
                Defines = defines
            };
            var output = processor.Process(input, processorContext);

            Assert.NotNull(output);

            // TODO: Should we test the writer?
        }
예제 #7
0
        public void ColorKey()
        {
            var context = new TestProcessorContext(TargetPlatform.Windows, "dummy.xnb");

            var processor = new TextureProcessor
            {
                ColorKeyColor      = Color.Red,
                ColorKeyEnabled    = true,
                GenerateMipmaps    = false,
                PremultiplyAlpha   = false,
                ResizeToPowerOfTwo = false,
                TextureFormat      = TextureProcessorOutputFormat.Color
            };

            var face = new PixelBitmapContent <Color>(8, 8);

            Fill(face, Color.Red);
            var input = new Texture2DContent();

            input.Faces[0] = face;

            var output = processor.Process(input, context);

            Assert.NotNull(output);
            Assert.AreEqual(1, output.Faces.Count);
            Assert.AreEqual(1, output.Faces[0].Count);

            Assert.IsAssignableFrom <PixelBitmapContent <Color> >(output.Faces[0][0]);
            var outFace = (PixelBitmapContent <Color>)output.Faces[0][0];

            Assert.AreEqual(8, outFace.Width);
            Assert.AreEqual(8, outFace.Height);

            for (var y = 0; y < outFace.Height; y++)
            {
                for (var x = 0; x < outFace.Width; x++)
                {
                    Assert.AreEqual(Color.Transparent, outFace.GetPixel(x, y));
                }
            }
        }
        public void ColorConversion()
        {
            var context = new TestProcessorContext(TargetPlatform.Windows, "dummy.xnb");

            var processor = new FontTextureProcessor
            {
                FirstCharacter   = '0',
                PremultiplyAlpha = false
            };

            var face = new PixelBitmapContent <Color>(32, 9);

            var O         = Color.Transparent.PackedValue;
            var M         = Color.Fuchsia.PackedValue;
            var R         = Color.Red.PackedValue;
            var G         = Color.Green.PackedValue;
            var B         = Color.Blue.PackedValue;
            var W         = Color.White.PackedValue;
            var pixelData = new[]
            {
                M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M,
                M, O, O, O, O, O, O, M, M, O, O, O, O, O, O, M, M, O, O, O, O, O, O, M, M, O, O, O, O, O, O, M,
                M, O, O, W, W, O, O, M, M, O, O, O, R, O, O, M, M, O, G, G, G, O, O, M, M, O, B, B, B, B, O, M,
                M, O, W, O, O, W, O, M, M, O, O, R, R, O, O, M, M, O, O, O, O, G, O, M, M, O, O, O, B, O, O, M,
                M, O, W, O, O, W, O, M, M, O, O, O, R, O, O, M, M, O, O, G, G, O, O, M, M, O, O, B, B, O, O, M,
                M, O, W, O, O, W, O, M, M, O, O, O, R, O, O, M, M, O, G, O, O, O, O, M, M, O, O, O, O, B, O, M,
                M, O, O, W, W, O, O, M, M, O, R, R, R, R, O, M, M, O, G, G, G, G, O, M, M, O, B, B, B, O, O, M,
                M, O, O, O, O, O, O, M, M, O, O, O, O, O, O, M, M, O, O, O, O, O, O, M, M, O, O, O, O, O, O, M,
                M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M, M,
            };
            var pixelBytes = new byte[face.Width * 4 * face.Height];

            Buffer.BlockCopy(pixelData, 0, pixelBytes, 0, pixelData.Length * 4);
            face.SetPixelData(pixelBytes);
            var input = new Texture2DContent();

            input.Faces[0] = face;

            var output = processor.Process(input, context);

            Assert.NotNull(output);

            Assert.AreEqual(output.CharacterMap[0], '0');
            Assert.AreEqual(output.CharacterMap[1], '1');
            Assert.AreEqual(output.CharacterMap[2], '2');
            Assert.AreEqual(output.CharacterMap[3], '3');

            Assert.AreEqual(1, output.Texture.Faces.Count);
            Assert.AreEqual(1, output.Texture.Faces[0].Count);

            Assert.IsAssignableFrom <PixelBitmapContent <Color> >(output.Texture.Faces[0][0]);
            var outFace = (PixelBitmapContent <Color>)output.Texture.Faces[0][0];

            for (var i = 0; i < 4; ++i)
            {
                // (2, 2, 4, 5) is the top,left and width,height of the first glyph. All test glyphs are 4x5
                var inRect  = new Rectangle(i * 8 + 2, 2, 4, 5);
                var outRect = output.Glyphs[i];
                Assert.AreEqual(inRect.Width, outRect.Width);
                Assert.AreEqual(inRect.Height, outRect.Height);
                for (var y = 0; y < inRect.Height; ++y)
                {
                    for (var x = 0; x < inRect.Width; ++x)
                    {
                        Assert.AreEqual(pixelData[(x + inRect.Left) + (y + inRect.Top) * face.Width], outFace.GetPixel(x + outRect.Left, y + outRect.Top).PackedValue);
                    }
                }
            }

            Assert.AreEqual(new Rectangle(1, 1, 6, 7), output.Cropping[0]);
            Assert.AreEqual(new Rectangle(1, 1, 6, 7), output.Cropping[1]);
            Assert.AreEqual(new Rectangle(1, 1, 6, 7), output.Cropping[2]);
            Assert.AreEqual(new Rectangle(1, 1, 6, 7), output.Cropping[3]);
        }
        public void BasicMeshTests()
        {
            var input = CreateBasicMesh();

            var processorContext = new TestProcessorContext(TargetPlatform.Windows, "dummy.xnb");
            var processor        = new ModelProcessor
            {
                RotationX = 10,
                RotationY = 20,
                RotationZ = 30
            };
            var output = processor.Process(input, processorContext);

            // The transform the processor above is applying to the model.
            var processorXform = Matrix.CreateRotationZ(MathHelper.ToRadians(30)) *
                                 Matrix.CreateRotationX(MathHelper.ToRadians(10)) *
                                 Matrix.CreateRotationY(MathHelper.ToRadians(20));

            // Test some basics.
            Assert.NotNull(output);
            Assert.NotNull(output.Meshes);
            Assert.AreEqual(2, output.Meshes.Count);
            Assert.NotNull(output.Bones);
            Assert.AreEqual(3, output.Bones.Count);
            Assert.NotNull(output.Root);
            Assert.AreEqual(output.Root, output.Bones[0]);

            // Stuff to make the tests below cleaner.
            var inputMesh1 = input.Children[0] as MeshContent;

            Assert.NotNull(inputMesh1);
            var inputMesh2 = input.Children[1] as MeshContent;

            Assert.NotNull(inputMesh2);

            // Test the bones.
            Assert.AreEqual("Root", output.Bones[0].Name);
            Assert.That(input.Transform, Is.EqualTo(output.Bones[0].Transform).Using(MatrixComparer.Epsilon));
            Assert.AreEqual("Mesh1", output.Bones[1].Name);
            Assert.That(Matrix.Identity, Is.EqualTo(output.Bones[1].Transform).Using(MatrixComparer.Epsilon));
            Assert.AreEqual("Mesh2", output.Bones[2].Name);
            Assert.That(Matrix.Identity, Is.EqualTo(output.Bones[2].Transform).Using(MatrixComparer.Epsilon));

            // Test the first mesh.
            {
                var mesh = output.Meshes[0];
                Assert.AreEqual("Mesh1", mesh.Name);
                Assert.AreEqual(output.Bones[1], mesh.ParentBone);
                Assert.AreEqual(inputMesh1, mesh.SourceMesh);
                Assert.AreEqual(new BoundingSphere(Vector3.Zero, 0), mesh.BoundingSphere);

                Assert.NotNull(mesh.MeshParts);
                Assert.AreEqual(1, mesh.MeshParts.Count);

                var part = mesh.MeshParts[0];
                Assert.NotNull(part);
                Assert.IsNull(part.IndexBuffer);
                Assert.IsNull(part.VertexBuffer);
                Assert.AreEqual(0, part.NumVertices);
                Assert.AreEqual(0, part.PrimitiveCount);
                Assert.AreEqual(0, part.StartIndex);
                Assert.AreEqual(0, part.VertexOffset);

                Assert.IsAssignableFrom <BasicMaterialContent>(part.Material);
                var material = part.Material as BasicMaterialContent;
                Assert.NotNull(material);
                Assert.IsNotEmpty(material.OpaqueData);
                Assert.IsNull(material.Name);
                Assert.IsNull(material.Identity);
                Assert.IsNull(material.Alpha);
                Assert.IsNull(material.DiffuseColor);
                Assert.IsNull(material.EmissiveColor);
                Assert.IsNull(material.SpecularColor);
                Assert.IsNull(material.SpecularPower);
                Assert.IsNull(material.Texture);
                Assert.IsEmpty(material.Textures);
                Assert.IsTrue(material.OpaqueData.ContainsKey("VertexColorEnabled"));
                Assert.IsNotNull(material.VertexColorEnabled);
                Assert.IsFalse(material.VertexColorEnabled.Value);
            }

            // Test the second mesh.
            {
                var mesh = output.Meshes[1];
                Assert.AreEqual("Mesh2", mesh.Name);
                Assert.AreEqual(output.Bones[2], mesh.ParentBone);
                Assert.AreEqual(inputMesh2, mesh.SourceMesh);
                Assert.That(new BoundingSphere(new Vector3(0.3809527f, 0.5858122f, 0.5115654f), 0.8660253f),
                            Is.EqualTo(mesh.BoundingSphere).Using(BoundingSphereComparer.Epsilon));

                Assert.NotNull(mesh.MeshParts);
                Assert.AreEqual(1, mesh.MeshParts.Count);

                var part = mesh.MeshParts[0];
                Assert.NotNull(part);
                Assert.AreEqual(1, part.PrimitiveCount);
                Assert.AreEqual(0, part.StartIndex);
                Assert.AreEqual(0, part.VertexOffset);
                Assert.AreEqual(3, part.NumVertices);

                Assert.NotNull(part.IndexBuffer);
                Assert.AreEqual(3, part.IndexBuffer.Count);
                Assert.AreEqual(0, part.IndexBuffer[0]);
                Assert.AreEqual(1, part.IndexBuffer[1]);
                Assert.AreEqual(2, part.IndexBuffer[2]);

                Assert.NotNull(part.VertexBuffer);
                Assert.NotNull(part.VertexBuffer.VertexData);
                var vertexData = part.VertexBuffer.VertexData;
                Assert.AreEqual(36, vertexData.Length);
                var positionArray = ArrayUtil.ConvertTo <Vector3>(vertexData);
                Assert.AreEqual(3, positionArray.Length);
                Assert.AreEqual(Vector3.Transform(new Vector3(0, 0, 0), processorXform), positionArray[0]);
                Assert.AreEqual(Vector3.Transform(new Vector3(1, 0, 0), processorXform), positionArray[1]);
                Assert.AreEqual(Vector3.Transform(new Vector3(1, 1, 1), processorXform), positionArray[2]);

                Assert.IsAssignableFrom <BasicMaterialContent>(part.Material);
                var material = part.Material as BasicMaterialContent;
                Assert.NotNull(material);
                Assert.IsNotEmpty(material.OpaqueData);
                Assert.AreEqual("Material1", material.Name);
                Assert.IsNull(material.Identity);
                Assert.IsTrue(material.OpaqueData.ContainsKey("Alpha"));
                Assert.NotNull(material.Alpha);
                Assert.AreEqual(0.5f, material.Alpha.Value);
                Assert.IsTrue(material.OpaqueData.ContainsKey("DiffuseColor"));
                Assert.NotNull(material.DiffuseColor);
                Assert.AreEqual(Color.Red.ToVector3(), material.DiffuseColor.Value);
                Assert.IsNull(material.EmissiveColor);
                Assert.IsNull(material.SpecularColor);
                Assert.IsNull(material.SpecularPower);
                Assert.IsNull(material.Texture);
                Assert.IsEmpty(material.Textures);
                Assert.IsTrue(material.OpaqueData.ContainsKey("VertexColorEnabled"));
                Assert.IsNotNull(material.VertexColorEnabled);
                Assert.IsFalse(material.VertexColorEnabled.Value);
            }
        }
        public void DefaultEffectTest()
        {
            NodeContent input;
            {
                input = new NodeContent();

                var mesh = new MeshContent()
                {
                    Name = "Mesh1"
                };
                mesh.Positions.Add(new Vector3(0, 0, 0));
                mesh.Positions.Add(new Vector3(1, 0, 0));
                mesh.Positions.Add(new Vector3(1, 1, 1));

                var geom = new GeometryContent();
                geom.Vertices.Add(0);
                geom.Vertices.Add(1);
                geom.Vertices.Add(2);
                geom.Indices.Add(0);
                geom.Indices.Add(1);
                geom.Indices.Add(2);

                geom.Vertices.Channels.Add(VertexChannelNames.TextureCoordinate(0), new[]
                {
                    new Vector2(0, 0),
                    new Vector2(1, 0),
                    new Vector2(1, 1),
                });

                var wieghts = new BoneWeightCollection();
                wieghts.Add(new BoneWeight("bone1", 0.5f));
                geom.Vertices.Channels.Add(VertexChannelNames.Weights(0), new[]
                {
                    wieghts,
                    wieghts,
                    wieghts
                });

                mesh.Geometry.Add(geom);
                input.Children.Add(mesh);

                var bone1 = new BoneContent {
                    Name = "bone1", Transform = Matrix.CreateTranslation(0, 1, 0)
                };
                input.Children.Add(bone1);

                var anim = new AnimationContent()
                {
                    Name     = "anim1",
                    Duration = TimeSpan.Zero
                };
                input.Animations.Add(anim.Name, anim);
            }

            var processorContext = new TestProcessorContext(TargetPlatform.Windows, "dummy.xnb");
            var processor        = new ModelProcessor
            {
                DefaultEffect = MaterialProcessorDefaultEffect.SkinnedEffect,
            };

            var output = processor.Process(input, processorContext);

            // TODO: Not sure why, but XNA always returns a BasicMaterialContent
            // even when we specify SkinnedEffect as the default.  We need to fix
            // the test first before we can enable the assert here.

            //Assert.IsInstanceOf(typeof(SkinnedMaterialContent), output.Meshes[0].MeshParts[0].Material);
        }
예제 #11
0
        public void BuildLocalizedFont(TargetPlatform platform, TextureProcessorOutputFormat format)
        {
            var context   = new TestProcessorContext(platform, "Localized.xnb");
            var processor = new LocalizedFontProcessor()
            {
                TextureFormat    = format,
                PremultiplyAlpha = true,
            };

            LocalizedFontDescription fontDescription = null;

            using (var fs = File.OpenRead(Path.Combine("Assets", "Fonts", "Localized.spritefont")))
                using (var input = XmlReader.Create(new StreamReader(fs)))
                    fontDescription = IntermediateSerializer.Deserialize <LocalizedFontDescription>(input, "");
            fontDescription.Identity = new ContentIdentity("Localized.spritefont");

            var output = processor.Process(fontDescription, context);

            Assert.IsNotNull(output, "output should not be null");
            Assert.IsNotNull(output.Texture, "output.Texture should not be null");
            var textureType = output.Texture.Faces[0][0].GetType();

            switch (format)
            {
            case TextureProcessorOutputFormat.Color:
                Assert.IsTrue(textureType == typeof(PixelBitmapContent <Color>));
                break;

            case TextureProcessorOutputFormat.Color16Bit:
                Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565>));
                break;

            case TextureProcessorOutputFormat.Compressed:
                switch (platform)
                {
                case TargetPlatform.Windows:
                case TargetPlatform.DesktopGL:
                    Assert.IsTrue(textureType == typeof(Dxt3BitmapContent));
                    break;

                case TargetPlatform.iOS:
                    Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
                    break;

                case TargetPlatform.Android:
                    Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
                    break;
                }
                break;

            case TextureProcessorOutputFormat.PvrCompressed:
                // because the font is not power of 2 we should use Brga4444
                Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
                break;

            case TextureProcessorOutputFormat.Etc1Compressed:
                // because the font has Alpha we should use Brga4444
                Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
                break;

            default:
                Assert.Fail("Test not written for " + format);
                break;
            }
        }