コード例 #1
0
        /// <summary>
        /// Converts all bitmaps for this texture to a different format.
        /// </summary>
        /// <param name="newBitmapType">
        /// Type being converted to.
        /// The new type must be a subclass of BitmapContent,
        /// such as PixelBitmapContent or DxtBitmapContent.
        /// </param>
        public void ConvertBitmapType(Type newBitmapType)
        {
            if (newBitmapType == null)
            {
                throw new ArgumentNullException(nameof(newBitmapType));
            }

            if (!newBitmapType.IsSubclassOf(typeof(BitmapContent)))
            {
                throw new ArgumentException(
                          $"Type '{newBitmapType}' is not a subclass of BitmapContent.");
            }

            if (newBitmapType.IsAbstract)
            {
                throw new ArgumentException(
                          $"Type '{newBitmapType}' is abstract and cannot be allocated.");
            }

            if (newBitmapType.ContainsGenericParameters)
            {
                throw new ArgumentException(
                          $"Type '{newBitmapType}' contains generic parameters and cannot be allocated.");
            }

            if (newBitmapType.GetConstructor(new Type[2] {
                typeof(int), typeof(int)
            }) == null)
            {
                throw new ArgumentException(
                          $"Type '{newBitmapType} does not have a " +
                          $"constructor with signature (int, int) and cannot be allocated.");
            }

            foreach (var mipChain in Faces)
            {
                for (var i = 0; i < mipChain.Count; i++)
                {
                    var src = mipChain[i];
                    if (src.GetType() != newBitmapType)
                    {
                        var dst = (BitmapContent)Activator.CreateInstance(
                            newBitmapType, new object[] { src.Width, src.Height });

                        BitmapContent.Copy(src, dst);
                        mipChain[i] = dst;
                    }
                }
            }
        }
コード例 #2
0
        // Once arranging is complete, copies each glyph to its chosen position in the single larger output bitmap.
        static PixelBitmapContent <Color> CopyGlyphsToOutput(
            List <ArrangedGlyph> glyphs, int width, int height)
        {
            var output = new PixelBitmapContent <Color>(width, height);

            foreach (var glyph in glyphs)
            {
                var sourceGlyph       = glyph.Source;
                var sourceRegion      = sourceGlyph.Subrect;
                var destinationRegion = new Rectangle(glyph.X + 1, glyph.Y + 1, sourceRegion.Width, sourceRegion.Height);

                BitmapContent.Copy(sourceGlyph.Bitmap, sourceRegion, output, destinationRegion);

                sourceGlyph.Bitmap  = output;
                sourceGlyph.Subrect = destinationRegion;
            }

            return(output);
        }
コード例 #3
0
        internal static PixelBitmapContent <RgbaVector> Resize(
            this BitmapContent bitmap, int newWidth, int newHeight)
        {
            BitmapContent src = bitmap;

            src.TryGetFormat(out SurfaceFormat format);
            if (format != SurfaceFormat.Vector4)
            {
                var v4 = new PixelBitmapContent <RgbaVector>(src.Width, src.Height);
                BitmapContent.Copy(src, v4);
                src = v4;
            }

            using (var image = Image.WrapMemory <RgbaVector>(src.GetPixelData(), new Size(src.Height, src.Width)))
                using (var resized = image.ProcessRows(x => x.Resize(new Size(newWidth, newHeight), 0)))
                {
                    var result = new PixelBitmapContent <RgbaVector>(newWidth, newHeight);
                    result.SetPixelData(resized.GetPixelSpan());
                    return(result);
                }
        }
コード例 #4
0
        /// <summary>
        /// Generates a full set of mipmaps for the texture.
        /// </summary>
        /// <param name="overwriteExistingMipmaps">
        /// true if the existing mipmap set is replaced with the new set; false otherwise.
        /// </param>
        public virtual void GenerateMipmaps(bool overwriteExistingMipmaps)
        {
            // If we already have mipmaps and we're not supposed to overwrite
            // them then return without any generation.
            if (!overwriteExistingMipmaps && Faces.Any(f => f.Count > 1))
            {
                return;
            }

            // Generate the mips for each face.
            foreach (var face in Faces)
            {
                // Remove any existing mipmaps.
                var faceBitmap = face[0];
                face.Clear();
                face.Add(faceBitmap);
                var faceType = faceBitmap.GetType();
                int width    = faceBitmap.Width;
                int height   = faceBitmap.Height;

                while (width > 1 || height > 1)
                {
                    if (width > 1)
                    {
                        width /= 2;
                    }
                    if (height > 1)
                    {
                        height /= 2;
                    }

                    var mip = (BitmapContent)Activator.CreateInstance(
                        faceType, new object[] { width, height });

                    BitmapContent.Copy(faceBitmap, mip);
                    face.Add(mip);
                }
            }
        }