BansheeEngine/MBansheeEngine/PixelData.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;

namespace BansheeEngine
{
    // Do not modify, IDs must match C++ enum PixelFormat
    public enum PixelFormat
    {
        // 8-bit pixel format, all bits red.
        R8 = 1,
        // 2 byte pixel format, 1 byte red, 1 byte green.
        R8G8 = 2,
        // 24-bit pixel format, 8 bits for red, green and blue.
        R8G8B8 = 3,
        // 32-bit pixel format, 8 bits for red, green, blue and alpha.
        R8G8B8A8 = 8,
        // DXT1/BC1 format containing opaque RGB or 1-bit alpha RGB. 4 bits per pixel.
        BC1 = 13,
        // DXT3/BC2 format containing RGB with premultiplied alpha. 4 bits per pixel.
        BC1a = 14,
        // DXT3/BC2 format containing RGB with explicit alpha. 8 bits per pixel.
        BC2 = 15,
        // DXT5/BC2 format containing RGB with explicit alpha. 8 bits per pixel. Better alpha gradients than BC2.
        BC3 = 16,
        // One channel compressed format. 4 bits per pixel.
        BC4 = 17,
        // Two channel compressed format. 8 bits per pixel.
        BC5 = 18,
        // Format storing RGB in half (16-bit) floating point format usable for HDR. 8 bits per pixel.
        BC6H = 19,
        // Format storing RGB with optional alpha channel. Similar to BC1/BC2/BC3 formats but with higher quality and higher decompress overhead. 8 bits per pixel.
        BC7 = 20,
        // 16-bit pixel format, 16 bits (float) for red
        Float16_R = 21,
        // 32-bit, 2-channel s10e5 floating point pixel format, 16-bit red, 16-bit green
        Float16_RG = 22,
        // 48-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue
        Float16_RGB = 23,
        // 64-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue, 16 bits (float) for alpha
        Float16_RGBA = 24,
        // 32-bit pixel format, 32 bits (float) for red
        Float32_R = 25,
        // 64-bit, 2-channel floating point pixel format, 32-bit red, 32-bit green
        Float32_RG = 26,
        // 96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
        Float32_RGB = 27,
        // 128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha
        Float32_RGBA = 28,
        // Depth stencil format, 32bit depth, 8bit stencil + 24 unused
        D32_S8X24 = 29,
        // Depth stencil fomrat, 24bit depth + 8bit stencil
        D24S8 = 30,
        // Depth format, 32bits
        D32 = 31,
        // Depth format, 16bits
        D16 = 32
    };

    public sealed class PixelData : ScriptObject
    {
        public PixelVolume Extents
        {
            get
            {
                PixelVolume volume;
                Internal_GetExtents(mCachedPtr, out volume);
                return volume;
            }
        }

        public PixelFormat Format
        {
            get
            {
                PixelFormat format;
                Internal_GetFormat(mCachedPtr, out format);
                return format;
            }
        }

        public int RawRowPitch
        {
            get
            {
                int rowPitch;
                Internal_GetRowPitch(mCachedPtr, out rowPitch);
                return rowPitch;
            }
        }

        public int RawSlicePitch
        {
            get
            {
                int slicePitch;
                Internal_GetSlicePitch(mCachedPtr, out slicePitch);
                return slicePitch;
            }
        }

        public int RawSize
        {
            get
            {
                int size;
                Internal_GetSize(mCachedPtr, out size);
                return size;
            }
        }

        public bool RawIsConsecutive
        {
            get
            {
                bool isConsecutive;
                Internal_GetIsConsecutive(mCachedPtr, out isConsecutive);
                return isConsecutive;
            }
        }

        public PixelData(PixelVolume volume, PixelFormat format)
        {
            Internal_CreateInstance(this, volume, format);
        }

        public PixelData(int width, int height, PixelFormat format)
        {
            Internal_CreateInstance(this, new PixelVolume(0, 0, width, height), format);
        }

        public PixelData(int width, int height, int depth, PixelFormat format)
        {
            Internal_CreateInstance(this, new PixelVolume(0, 0, 0, width, height, depth), format);
        }

        public Color GetPixel(int x, int y, int z = 0)
        {
            Color pixel;
            Internal_GetPixel(mCachedPtr, x, y, z, out pixel);
            return pixel;
        }

        public void SetPixel(Color color, int x, int y, int z = 0)
        {
            Internal_SetPixel(mCachedPtr, x, y, z, color);
        }

        public Color[] GetPixels()
        {
            Color[] pixels;
            Internal_GetPixels(mCachedPtr, out pixels);
            return pixels;
        }

        public void SetPixels(Color[] pixels)
        {
            Internal_SetPixels(mCachedPtr, pixels);
        }

        public byte[] GetRawPixels()
        {
            byte[] pixels;
            Internal_GetRawPixels(mCachedPtr, out pixels);
            return pixels;
        }

        public void SetRawPixels(byte[] pixels)
        {
            Internal_SetRawPixels(mCachedPtr, pixels);
        }

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_CreateInstance(PixelData instance, PixelVolume volume, PixelFormat format);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetPixel(IntPtr thisPtr, int x, int y, int z, out Color value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_SetPixel(IntPtr thisPtr, int x, int y, int z, Color value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetPixels(IntPtr thisPtr, out Color[] value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_SetPixels(IntPtr thisPtr, Color[] value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetRawPixels(IntPtr thisPtr, out byte[] value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_SetRawPixels(IntPtr thisPtr, byte[] value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetExtents(IntPtr thisPtr, out PixelVolume value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetFormat(IntPtr thisPtr, out PixelFormat value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetRowPitch(IntPtr thisPtr, out int value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetSlicePitch(IntPtr thisPtr, out int value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetSize(IntPtr thisPtr, out int value);

        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_GetIsConsecutive(IntPtr thisPtr, out bool value);
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct PixelVolume
    {
        private int left, top, right, bottom, front, back;

        public int Left { get { return left; } }
        public int Right { get { return right; } }
        public int Top { get { return top; } }
        public int Bottom { get { return bottom; } }
        public int Front { get { return front; } }
        public int Back { get { return back; } }
        public int Width { get { return right - left; } }
        public int Height { get { return bottom - top; } }
        public int Depth { get { return back - front; } }

        public PixelVolume(int left, int top, int right, int bottom)
        {
            this.left = left;
            this.right = right;
            this.top = top;
            this.bottom = bottom;
            this.front = 0;
            this.back = 1;
        }

        public PixelVolume(int left, int top, int front, int right, int bottom, int back)
        {
            this.left = left;
            this.right = right;
            this.top = top;
            this.bottom = bottom;
            this.front = front;
            this.back = back;
        }
    };
}