Exemple #1
0
        private static List <byte[]> GetMipMapData(DdsFile file)
        {
            const int     minimumWidth  = 4;
            const int     minimumHeight = 4;
            List <byte[]> mipMapDatas   = new List <byte[]>();

            byte[] data         = file.Data;
            int    dataOffset   = 0;
            int    width        = file.Header.Width;
            int    height       = file.Header.Height;
            int    depth        = file.Header.Depth == 0 ? 1 : file.Header.Depth;
            int    mipMapsCount = file.Header.Flags.HasFlag(DdsFileHeaderFlags.MipMap) ? file.Header.MipMapCount : 1;

            for (int i = 0; i < mipMapsCount; i++)
            {
                int size   = DdsPixelFormat.CalculateImageSize(file.Header.PixelFormat, width, height, depth);
                var buffer = new byte[size];
                Array.Copy(data, dataOffset, buffer, 0, size);
                mipMapDatas.Add(buffer);
                dataOffset += size;
                width       = Math.Max(width / 2, minimumWidth);
                height      = Math.Max(height / 2, minimumHeight);
            }
            return(mipMapDatas);
        }
Exemple #2
0
        private static DdsFile GenerateDds(DdsOptions options)
        {
            DdsFile ddsFile = new DdsFile();

            ddsFile.Header = new DdsFileHeader
            {
                Size        = DdsFileHeader.DefaultHeaderSize,
                Flags       = DdsFileHeaderFlags.Texture,
                Width       = options.Width,
                Height      = options.Height,
                Depth       = options.Depth,
                MipMapCount = options.MipMapCount,
                Caps        = DdsSurfaceFlags.Texture,
                PixelFormat = options.PixelFormat
            };

            if (ddsFile.Header.Depth > 1)
            {
                ddsFile.Header.Flags |= DdsFileHeaderFlags.Volume;
            }

            int mipMapCount = ddsFile.Header.MipMapCount;

            if (ddsFile.Header.MipMapCount == 1)
            {
                ddsFile.Header.MipMapCount = 0;
            }
            else if (ddsFile.Header.MipMapCount > 1)
            {
                ddsFile.Header.Flags |= DdsFileHeaderFlags.MipMap;
                ddsFile.Header.Caps  |= DdsSurfaceFlags.MipMap;
            }

            const int minimumWidth     = 4;
            const int minimumHeight    = 4;
            int       mipMapHeight     = ddsFile.Header.Height;
            int       mipMapWidth      = ddsFile.Header.Width;
            int       mipMapDepth      = ddsFile.Header.Depth == 0 ? 1 : ddsFile.Header.Depth;
            int       mipMapBufferSize = 0;

            for (int i = 0; i < mipMapCount; i++)
            {
                int mipMapSize = DdsPixelFormat.CalculateImageSize(ddsFile.Header.PixelFormat, mipMapWidth, mipMapHeight, mipMapDepth);
                mipMapBufferSize += mipMapSize;
                mipMapWidth       = Math.Max(mipMapWidth / 2, minimumWidth);
                mipMapHeight      = Math.Max(mipMapHeight / 2, minimumHeight);
            }

            ddsFile.Data = new byte[mipMapBufferSize];
            for (int i = 0; i < mipMapBufferSize; i++)
            {
                ddsFile.Data[i] = (byte)(i % 0xFF);
            }


            return(ddsFile);
        }