示例#1
0
        CoreTexture readFromBinaryReader(Func <UInt32> uintReader, Func <UInt32, byte[]> byteReader)
        {
            CoreTexture resultTexture = new CoreTexture();

            resultTexture.glType                = uintReader();
            resultTexture.glTypeSize            = uintReader();
            resultTexture.glFormat              = uintReader();
            resultTexture.glInternalFormat      = uintReader();
            resultTexture.glBaseInternalFormat  = uintReader();
            resultTexture.pixelWidth            = uintReader();
            resultTexture.pixelHeight           = uintReader();
            resultTexture.pixelDepth            = uintReader();
            resultTexture.numberOfArrayElements = uintReader();
            resultTexture.numberOfFaces         = uintReader();
            UInt32 numberOfMipmapLevels = uintReader();
            UInt32 bytesOfKeyValueData  = uintReader();

            resultTexture.mipmapLevels = new CoreTextureMipmapLevel[numberOfMipmapLevels == 0 ? 1 : numberOfMipmapLevels];

            readKeyValuePairsFromBinaryReader(uintReader, byteReader, bytesOfKeyValueData, ref resultTexture);

            readMipmapLevelsFromBinaryReader(uintReader, byteReader, ref resultTexture);

            return(resultTexture);
        }
示例#2
0
        public CoreTexture ToCoreTexture(GenericImage image, IGLDataFormat dataFormat)
        {
            CoreTexture texture = new CoreTexture();

            texture.glType                = dataFormat.Value;
            texture.glFormat              = Value;
            texture.glTypeSize            = 1;
            texture.pixelWidth            = image.width;
            texture.pixelHeight           = image.height;
            texture.pixelDepth            = image.depth == 1 ? 0 : image.depth;
            texture.numberOfFaces         = image.faces;
            texture.numberOfArrayElements = image.arrays == 1 ? 0 : image.arrays;

            texture.mipmapLevels = new CoreTextureMipmapLevel[image.mipmapLevels.Length];
            for (int mip = 0; mip < texture.mipmapLevels.Length; ++mip)
            {
                CoreTextureMipmapLevel mipTexture = new CoreTextureMipmapLevel();

                mipTexture.pixels         = ToCoreMipTexture(image, dataFormat, mip).ToArray();
                texture.mipmapLevels[mip] = mipTexture;
            }

            texture.keyValuePairs = new CoreTextureKeyValuePair[1] {
                new CoreTextureKeyValuePair("FileGenerator", "KTXToolkit by Tiemo Jung")
            };

            return(texture);
        }
示例#3
0
            public void CopyTo(ref CoreTexture texture)
            {
                texture.glType     = 0x1401;
                texture.glTypeSize = 1;
                if (BitsPerPixel > 24)
                {
                    texture.glBaseInternalFormat =
                        texture.glInternalFormat = 0x1908;
                    texture.glFormat             = 0x80E1;
                }
                else
                {
                    texture.glBaseInternalFormat =
                        texture.glInternalFormat = 0x1907;
                    texture.glFormat             = 0x80E0;
                }

                texture.pixelWidth            = (UInt32)Width;
                texture.pixelHeight           = (UInt32)Height;
                texture.pixelDepth            = 0;
                texture.numberOfArrayElements = 0;
                texture.numberOfFaces         = 1;
                texture.keyValuePairs         = new CoreTextureKeyValuePair[0];
                texture.mipmapLevels          = new CoreTextureMipmapLevel[1];
                texture.mipmapLevels[0]       = new CoreTextureMipmapLevel();
                if (BitsPerPixel >= 24)
                {
                    texture.mipmapLevels[0].pixels = UncompressedImage;
                }
                else
                {
                    // todo: use extended stuff...
                }
            }
示例#4
0
        public CoreTexture Load(string path)
        {
            TGAImage    image   = new TGAImage(path);
            CoreTexture texture = new CoreTexture();

            image.CopyTo(ref texture);
            return(texture);
        }
示例#5
0
        private void DisplayTexture(string name, CoreTexture texture)
        {
            ImageDisplay imageDisplay = new ImageDisplay(PluginList, texture);

            imageDisplay.Width  = (int)texture.pixelWidth;
            imageDisplay.Height = (int)texture.pixelHeight;
            imageDisplay.Text   = name;
            imageDisplay.Show(this);
        }
示例#6
0
 public ImageDisplay(IPlugin[] plugins, CoreTexture texture_)
 {
     InitializeComponent();
     PluginList  = plugins;
     texture     = texture_;
     AutoSize    = true;
     MinimumSize = new Size(158, 98);
     UpdateImageDisplay();
 }
示例#7
0
        public void Store(string path, CoreTexture texture, GenericImage image)
        {
            if (image.depth > 1)
            {
                MessageBox.Show("The image is a volumetric image, the container format can not store volumetric images"
                                , "Inconpatible image type"
                                , MessageBoxButtons.OK
                                , MessageBoxIcon.Error);
                return;
            }
            if (image.arrays > 1)
            {
                MessageBox.Show("The image is a array of images, the container format can not store an array of images"
                                , "Inconpatible image type"
                                , MessageBoxButtons.OK
                                , MessageBoxIcon.Error);
                return;
            }
            if (image.faces > 1)
            {
                MessageBox.Show("The image is a cubemap image, the container format can not store a cubemap image"
                                , "Inconpatible image type"
                                , MessageBoxButtons.OK
                                , MessageBoxIcon.Error);
                return;
            }
            if (image.mipmapLevels.Length > 1)
            {
                MessageBox.Show("The image has multiple mipmap levels, the container format does not support mipmap images, ony the first mipmap image is store"
                                , "Container can't store mipmaps"
                                , MessageBoxButtons.OK
                                , MessageBoxIcon.Information);
            }

            int[] buf = new int[] { 0, 0, 0, 255 };
            System.Drawing.Imaging.PixelFormat pfm = System.Drawing.Imaging.PixelFormat.Canonical;
            if (image.channels <= 3)
            {
                pfm = System.Drawing.Imaging.PixelFormat.Format24bppRgb;
            }
            Bitmap bitmap = new Bitmap((int)texture.pixelWidth, (int)texture.pixelHeight, pfm);

            for (int y = 0; y < bitmap.Height; ++y)
            {
                for (int x = 0; x < bitmap.Width; ++x)
                {
                    for (int c = 0; c < image.channels; ++c)
                    {
                        buf[c] = (byte)((image.mipmapLevels[0].pixels[(x + y * image.width) * image.channels + c]) * 255);
                    }
                    bitmap.SetPixel(x, y, Color.FromArgb(buf[3], buf[0], buf[1], buf[2]));
                }
            }

            bitmap.Save(path);
        }
示例#8
0
        protected List <double> ToGenericImagePixel(CoreTexture texture, IGLDataFormat dataFormat, int mipIndex, int pixelIndex)
        {
            List <double> byteBuffer = new List <double>();

            for (int channel = 0; channel < Channels; ++channel)
            {
                byteBuffer.Add(ToGenericImagePixelAtPixel(texture, dataFormat, mipIndex, pixelIndex, channel));
            }

            return(byteBuffer);
        }
示例#9
0
 void WriteKeyValuePairs(BinaryWriter writer, CoreTexture texture)
 {
     if (texture.keyValuePairs.Length == 0)
     {
         writer.Write((UInt32)0);
     }
     else
     {
         byte[] buffer = WriteKeyValuePairsToBuffer(texture);
         writer.Write((UInt32)buffer.Length);
         writer.Write(buffer);
     }
 }
示例#10
0
 void WriteImages(BinaryWriter writer, CoreTexture texture)
 {
     foreach (CoreTextureMipmapLevel mip in texture.mipmapLevels)
     {
         writer.Write((UInt32)mip.pixels.Length);
         writer.Write(mip.pixels);
         int padding = 3 - ((mip.pixels.Length + 3) % 4);
         for (int i = 0; i < padding; ++i)
         {
             writer.Write((byte)0);
         }
     }
 }
示例#11
0
        public CoreTexture Load(string path)
        {
            FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read);

            if (file == null)
            {
                return(null);
            }

            BinaryReader fileReader = new BinaryReader(file);
            CoreTexture  tex        = readFromBinaryReader(fileReader);

            file.Dispose();
            return(tex);
        }
示例#12
0
        public void Store(string path, CoreTexture texture, GenericImage image)
        {
            FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write);

            if (file == null)
            {
                return;
            }

            BinaryWriter fileWriter = new BinaryWriter(file);

            WriteToBinaryWriter(fileWriter, texture);
            file.Flush();
            file.Dispose();
        }
示例#13
0
        private void TransformTextureBack()
        {
            IGLDataFormat         dataFormat          = GetDataFormat(texture.glType);
            IGLPixelFormat        pixelFormat         = GetPixelFormat(texture.glFormat);
            IGLInteralPixelFormat internalPixelFormat = GetInternalPixelFormat(texture.glInternalFormat);

            CoreTexture tex = internalPixelFormat.ToCoreTexture(genericTexture, pixelFormat, dataFormat);

            if (tex != null)
            {
                texture = tex;
            }
            else
            {
                MessageBox.Show("Unable to convert image data", "Error while converting image data", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
示例#14
0
        override protected double ToGenericImagePixelAtPixel(CoreTexture texture, IGLDataFormat dataFormat, int mipIndex, int pixelIndex, int channelIndex)
        {
            long offset = pixelIndex * dataFormat.PixelSize(Channels);

            if (channelIndex == 0)
            {
                return(dataFormat.ToGenericFormat(texture.mipmapLevels[mipIndex].pixels, (int)offset, 2, Channels));
            }
            else if (channelIndex == 2)
            {
                return(dataFormat.ToGenericFormat(texture.mipmapLevels[mipIndex].pixels, (int)offset, 0, Channels));
            }
            else
            {
                return(dataFormat.ToGenericFormat(texture.mipmapLevels[mipIndex].pixels, (int)offset, channelIndex, Channels));
            }
        }
示例#15
0
        protected List <double> ToGenericMipImage(CoreTexture texture, IGLDataFormat dataFormat, int mipIndex)
        {
            int x = (int)texture.pixelWidth >> (int)mipIndex;
            int y = (int)texture.pixelHeight >> (int)mipIndex;
            int z = (int)texture.pixelDepth >> (int)mipIndex;

            x = x < 1 ? 1 : x;
            y = y < 1 ? 1 : y;
            z = z < 1 ? 1 : z;
            int pixels = (int)(texture.numberOfFaces * Math.Max(1, texture.numberOfArrayElements) * x * y * z);

            List <double> byteBuffer = new List <double>();

            for (int pixel = 0; pixel < pixels; ++pixel)
            {
                byteBuffer.AddRange(ToGenericImagePixel(texture, dataFormat, mipIndex, pixel));
            }
            return(byteBuffer);
        }
示例#16
0
 void WriteHeader(BinaryWriter writer, CoreTexture texture)
 {
     writer.Write(new byte[12] {
         0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
     });
     for (byte b = 1; b <= 4; ++b)
     {
         writer.Write(b);
     }
     writer.Write(texture.glType);
     writer.Write(texture.glTypeSize);
     writer.Write(texture.glFormat);
     writer.Write(texture.glInternalFormat);
     writer.Write(texture.glBaseInternalFormat);
     writer.Write(texture.pixelWidth);
     writer.Write(texture.pixelHeight);
     writer.Write(texture.pixelDepth);
     writer.Write(texture.numberOfArrayElements);
     writer.Write(texture.numberOfFaces);
     writer.Write((UInt32)texture.mipmapLevels.Length);
 }
示例#17
0
        public CoreTexture ToCoreTexture(GenericImage image, IGLPixelFormat pixelFormat, IGLDataFormat dataFormat)
        {
            CoreTexture tex = pixelFormat.ToCoreTexture(image, dataFormat);

            if (tex != null)
            {
                tex.glInternalFormat = Value;

                switch (GLValue)
                {
                case Values.GL_RED:
                    tex.glBaseInternalFormat = (UInt32)Values.GL_RED;
                    break;

                case Values.GL_RGB:
                case Values.GL_R3_G3_B2:
                case Values.GL_RGB4:
                case Values.GL_RGB5:
                case Values.GL_RGB8:
                case Values.GL_RGB10:
                case Values.GL_RGB12:
                case Values.GL_RGB16:
                    tex.glBaseInternalFormat = (UInt32)Values.GL_RGB;
                    break;

                case Values.GL_RGBA:
                case Values.GL_RGBA2:
                case Values.GL_RGBA4:
                case Values.GL_RGB5_A1:
                case Values.GL_RGBA8:
                case Values.GL_RGB10_A2:
                case Values.GL_RGBA12:
                case Values.GL_RGBA16:
                    tex.glBaseInternalFormat = (UInt32)Values.GL_RGBA;
                    break;
                }
            }
            return(tex);
        }
示例#18
0
        byte[] WriteKeyValuePairsToBuffer(CoreTexture texture)
        {
            UTF8Encoding transform = new UTF8Encoding(false, false);
            BinaryWriter writer    = new BinaryWriter(new MemoryStream());

            foreach (CoreTextureKeyValuePair pair in texture.keyValuePairs)
            {
                byte[] keyInBytes   = transform.GetBytes(pair.key);
                byte[] valueInBytes = transform.GetBytes(pair.value);
                UInt32 len          = (UInt32)(keyInBytes.Length + 1 + valueInBytes.Length + 1);
                writer.Write(len);
                writer.Write(keyInBytes);
                writer.Write((byte)0);
                writer.Write(valueInBytes);
                writer.Write((byte)0);
                uint padding = 3 - ((len + 3) % 4);
                for (uint p = 0; p < padding; ++p)
                {
                    writer.Write((byte)0);
                }
            }
            return(((MemoryStream)writer.BaseStream).ToArray());
        }
示例#19
0
        public GenericImage ToGenericImage(CoreTexture texture, IGLDataFormat dataFormat)
        {
            GenericImage image = null;

            if (texture.glFormat == Value && dataFormat.Value == texture.glType)
            {
                image              = new GenericImage();
                image.channels     = (uint)Channels;
                image.width        = texture.pixelWidth;
                image.height       = texture.pixelHeight;
                image.depth        = texture.pixelDepth != 0 ? texture.pixelDepth : 1;
                image.arrays       = texture.numberOfArrayElements != 0 ? texture.numberOfArrayElements : 1;
                image.faces        = texture.numberOfFaces;
                image.mipmapLevels = new GenericImageMipmapLevel[texture.mipmapLevels.Length];
                for (int level = 0; level < texture.mipmapLevels.Length; ++level)
                {
                    image.mipmapLevels[level]        = new GenericImageMipmapLevel();
                    image.mipmapLevels[level].pixels = ToGenericMipImage(texture, dataFormat, level).ToArray();
                }
            }

            return(image);
        }
示例#20
0
        // texture and image contain the same image, for some containers its easyer to use image instead of texture
        public void Store(string path, CoreTexture texture, GenericImage image)
        {
            TGAImage tga = new TGAImage(image);

            tga.Save(path);
        }
示例#21
0
        virtual protected double ToGenericImagePixelAtPixel(CoreTexture texture, IGLDataFormat dataFormat, int mipIndex, int pixelIndex, int channelIndex)
        {
            long offset = pixelIndex * dataFormat.PixelSize(Channels);

            return(dataFormat.ToGenericFormat(texture.mipmapLevels[mipIndex].pixels, (int)offset, channelIndex, Channels));
        }
示例#22
0
 void WriteToBinaryWriter(BinaryWriter writer, CoreTexture texture)
 {
     WriteHeader(writer, texture);
     WriteKeyValuePairs(writer, texture);
     WriteImages(writer, texture);
 }
示例#23
0
        public CoreTexture Load(string path)
        {
            Bitmap      image   = new Bitmap(path);
            CoreTexture texture = new CoreTexture();

            texture.glTypeSize = 1;
            texture.glType     = 0x1401;
            int channels = 0;

            switch (image.PixelFormat)
            {
            default:
            case System.Drawing.Imaging.PixelFormat.Undefined:
                return(null);

            case System.Drawing.Imaging.PixelFormat.Format16bppRgb555:
            case System.Drawing.Imaging.PixelFormat.Format16bppRgb565:
            case System.Drawing.Imaging.PixelFormat.Format24bppRgb:
            case System.Drawing.Imaging.PixelFormat.Format32bppRgb:
                texture.glFormat             = 0x1907;
                texture.glInternalFormat     = 0x1907;
                texture.glBaseInternalFormat = 0x1907;
                channels = 3;
                break;

            case System.Drawing.Imaging.PixelFormat.Indexed:
            case System.Drawing.Imaging.PixelFormat.Format1bppIndexed:
            case System.Drawing.Imaging.PixelFormat.Format4bppIndexed:
            case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
            case System.Drawing.Imaging.PixelFormat.Gdi:
            case System.Drawing.Imaging.PixelFormat.Alpha:
            case System.Drawing.Imaging.PixelFormat.PAlpha:
            case System.Drawing.Imaging.PixelFormat.Format16bppArgb1555:
            case System.Drawing.Imaging.PixelFormat.Format32bppPArgb:
            case System.Drawing.Imaging.PixelFormat.Format16bppGrayScale:
            case System.Drawing.Imaging.PixelFormat.Format48bppRgb:
            case System.Drawing.Imaging.PixelFormat.Format64bppPArgb:
            case System.Drawing.Imaging.PixelFormat.Canonical:
            case System.Drawing.Imaging.PixelFormat.Format32bppArgb:
            case System.Drawing.Imaging.PixelFormat.Format64bppArgb:
                texture.glFormat             = 0x1908;
                texture.glInternalFormat     = 0x1908;
                texture.glBaseInternalFormat = 0x1908;
                channels = 4;
                break;
            }
            texture.pixelWidth            = (UInt32)image.Width;
            texture.pixelHeight           = (UInt32)image.Height;
            texture.pixelDepth            = 0;
            texture.numberOfArrayElements = 0;
            texture.numberOfFaces         = 1;
            texture.keyValuePairs         = new CoreTextureKeyValuePair[0];
            texture.mipmapLevels          = new CoreTextureMipmapLevel[1];
            texture.mipmapLevels[0]       = new CoreTextureMipmapLevel(texture.pixelWidth * texture.pixelHeight * channels);
            byte[] pixBuf = new byte[] { 0, 0, 0, 1 };
            for (int y = 0; y < texture.pixelHeight; ++y)
            {
                for (int x = 0; x < texture.pixelWidth; ++x)
                {
                    Color color = image.GetPixel(x, y);
                    pixBuf[0] = color.R;
                    pixBuf[1] = color.G;
                    pixBuf[2] = color.B;
                    pixBuf[3] = color.A;
                    for (int channel = 0; channel < channels; ++channel)
                    {
                        int offset = (int)((x + y * texture.pixelWidth) * channels) + channel;
                        texture.mipmapLevels[0].pixels[offset] = pixBuf[channel];
                    }
                }
            }
            return(texture);
        }
示例#24
0
        void readKeyValuePairsFromBinaryReader(Func <UInt32> uintReader, Func <UInt32, byte[]> byteReader, UInt32 bytesOfKeyValueData, ref CoreTexture resultTexture)
        {
            List <CoreTextureKeyValuePair> keyValuePairs = new List <CoreTextureKeyValuePair>();

            while (bytesOfKeyValueData > 4)
            {
                UInt32 bytesRead;
                keyValuePairs.Add(readKeyValuePairFromBinaryReader(uintReader, byteReader, out bytesRead));
                bytesOfKeyValueData -= bytesRead;
            }

            if (bytesOfKeyValueData > 0)
            {
                // skip over rest
                byteReader(bytesOfKeyValueData);
            }

            resultTexture.keyValuePairs = keyValuePairs.ToArray();
        }
示例#25
0
        void readMipmapLevelFromBinaryReader(Func <UInt32> uintReader, Func <UInt32, byte[]> byteReader, ref CoreTexture resultTexture, UInt32 levelIndex)
        {
            UInt32 imageSize = uintReader();

            imageSize = (imageSize + 3) & ~(UInt32)3;
            resultTexture.mipmapLevels[levelIndex].pixels = byteReader(imageSize);
        }
示例#26
0
 void readMipmapLevelsFromBinaryReader(Func <UInt32> uintReader, Func <UInt32, byte[]> byteReader, ref CoreTexture resultTexture)
 {
     for (UInt32 level = 0; level < resultTexture.mipmapLevels.Length; ++level)
     {
         resultTexture.mipmapLevels[level] = new CoreTextureMipmapLevel();
         readMipmapLevelFromBinaryReader(uintReader, byteReader, ref resultTexture, level);
     }
 }
示例#27
0
 public GenericImage ToGenericImage(CoreTexture texture, IGLPixelFormat pixelFormat, IGLDataFormat dataFormat)
 {
     return(pixelFormat.ToGenericImage(texture, dataFormat));
 }