Beispiel #1
0
        public static Bitmap EtoBitmapFromRaw(IntSize2 size, byte[] srgbaData)
        {
            var bitmap         = new Bitmap(size.Width, size.Height, PixelFormat.Format32bppRgba);
            var alignedRowSpan = GraphicsHelper.AlignedRowSpan(size.Width, 4, 1);

            using (var bitmapData = bitmap.Lock())
            {
                for (var y = 0; y < size.Height; y++)
                {
                    var dataOffset   = y * alignedRowSpan;
                    var yf           = bitmapData.Flipped ? size.Height - 1 - y : y;
                    var bitmapOffset = yf * bitmapData.ScanWidth;
                    Marshal.Copy(srgbaData, dataOffset, bitmapData.Data + bitmapOffset, 4 * size.Width);
                }
            }
            return(bitmap);
        }
Beispiel #2
0
        public unsafe Texture GetUnityTexture()
        {
            if (!dirty)
            {
                return(unityTexture);
            }

            DestroyTexture();

            if (image is UcImage)
            {
                var ucImage = (UcImage)image;
                unityTexture = ucImage.UnityTexture;
                ownsTexture  = false;
                dirty        = false;
                return(unityTexture);
            }

            var rowSpan    = GraphicsHelper.AlignedRowSpan(image.Size.Width);
            var pixelArray = new Color32[image.Size.Area];
            var rawData    = image.GetRawData();

            fixed(byte *pRawData = rawData)
            for (int y = 0; y < image.Size.Height; y++)
                for (int x = 0; x < image.Size.Width; x++)
                {
                    var pixel = *(Color32 *)(pRawData + (rowSpan * y + sizeof(Color32) * x));

                    pixelArray[image.Size.Width * y + x] = pixel;
                }

            unityTexture = new Texture2D(image.Size.Width, image.Size.Height, TextureFormat.RGBA32, true, isNormalMap)
            {
                filterMode = FilterMode.Trilinear,
                anisoLevel = 16
            };
            unityTexture.SetPixels32(pixelArray);
            unityTexture.Apply(true, true);
            ownsTexture = true;

            dirty = false;
            return(unityTexture);
        }
Beispiel #3
0
        public static unsafe byte[] GetRawData(Image eImage)
        {
            var alignedRowSpan = GraphicsHelper.AlignedRowSpan(eImage.Size.Width, 4, 1);
            var data           = new byte[alignedRowSpan * eImage.Size.Height];

            var bitmap = new Bitmap(eImage);

            using (var bitmapData = bitmap.Lock())
            {
                if (!bitmapData.Flipped & bitmapData.BytesPerPixel == 4 && bitmapData.ScanWidth == alignedRowSpan)
                {
                    Marshal.Copy(bitmapData.Data, data, 0, data.Length);
                }
                else
                {
                    fixed(byte *pData = data)
                    {
                        for (var y = 0; y < eImage.Size.Height; y++)
                        {
                            var yf           = bitmapData.Flipped ? eImage.Size.Height - 1 - y : y;
                            var dstRowOffset = y * alignedRowSpan;
                            for (var x = 0; x < eImage.Size.Width; x++)
                            {
                                var color = bitmapData.GetPixel(x, yf);
                                var pDst  = pData + dstRowOffset + x * 4;
                                pDst[0] = (byte)color.Rb;
                                pDst[1] = (byte)color.Gb;
                                pDst[2] = (byte)color.Bb;
                                pDst[3] = (byte)color.Ab;
                            }
                        }
                    }
                }
            }
            return(data);
        }