BansheeEngine/CamelotCore/Include/CmPixelData.h

#pragma once

#include "CmPrerequisites.h"
#include "CmPixelVolume.h"
#include "CmGpuResourceData.h"
#include "CmIReflectable.h"

namespace CamelotFramework
{
	/** The pixel format used for images, textures, and render surfaces */
    enum PixelFormat
    {
        /// Unknown pixel format.
        PF_UNKNOWN = 0,
        /// 8-bit pixel format, all bits red
        PF_R8 = 1,
		/// 2 byte pixel format, 1 byte red, 1 byte green
		PF_R8G8 = 2,
        /// 24-bit pixel format, 8 bits for red, green and blue.
        PF_R8G8B8 = 3,
        /// 24-bit pixel format, 8 bits for blue, green and red.
        PF_B8G8R8 = 4,
        /// 32-bit pixel format, 8 bits for alpha, red, green and blue.
        PF_A8R8G8B8 = 5,
        /// 32-bit pixel format, 8 bits for blue, green, red and alpha.
        PF_A8B8G8R8 = 6,
        /// 32-bit pixel format, 8 bits for blue, green, red and alpha.
        PF_B8G8R8A8 = 7,
		/// 32-bit pixel format, 8 bits for red, green, blue and alpha.
		PF_R8G8B8A8 = 8,
        /// 32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue
        /// like PF_A8R8G8B8, but alpha will get discarded
        PF_X8R8G8B8 = 9,
        /// 32-bit pixel format, 8 bits for blue, 8 bits for green, 8 bits for red
        /// like PF_A8B8G8R8, but alpha will get discarded
        PF_X8B8G8R8 = 10,
		/// 32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue
		/// like PF_R8G8B8A8, but alpha will get discarded
		PF_R8G8B8X8 = 11,
		/// 32-bit pixel format, 8 bits for blue, 8 bits for green, 8 bits for red
		/// like PF_B8G8R8A8, but alpha will get discarded
		PF_B8G8R8X8 = 12,
		/// 3 byte pixel format, 1 byte for red, 1 byte for green, 1 byte for blue
		PF_BYTE_RGB = PF_R8G8B8,
		/// 3 byte pixel format, 1 byte for blue, 1 byte for green, 1 byte for red
		PF_BYTE_BGR = PF_B8G8R8,
		/// 4 byte pixel format, 1 byte for blue, 1 byte for green, 1 byte for red and one byte for alpha
		PF_BYTE_BGRA = PF_B8G8R8A8,
		/// 4 byte pixel format, 1 byte for red, 1 byte for green, 1 byte for blue, and one byte for alpha
		PF_BYTE_RGBA = PF_R8G8B8A8,      
        /// DDS (DirectDraw Surface) DXT1 format
        PF_DXT1 = 13,
        /// DDS (DirectDraw Surface) DXT2 format
        PF_DXT2 = 14,
        /// DDS (DirectDraw Surface) DXT3 format
        PF_DXT3 = 15,
        /// DDS (DirectDraw Surface) DXT4 format
        PF_DXT4 = 16,
        /// DDS (DirectDraw Surface) DXT5 format
        PF_DXT5 = 17,
		// 16-bit pixel format, 16 bits (float) for red
        PF_FLOAT16_R = 18,
		// 32-bit, 2-channel s10e5 floating point pixel format, 16-bit red, 16-bit green
		PF_FLOAT16_RG = 19,
        // 48-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue
        PF_FLOAT16_RGB = 20,
        // 64-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue, 16 bits (float) for alpha
        PF_FLOAT16_RGBA = 21,
		// 32-bit pixel format, 32 bits (float) for red
        PF_FLOAT32_R = 22,
		// 64-bit, 2-channel floating point pixel format, 32-bit red, 32-bit green
		PF_FLOAT32_RG = 23,
        // 96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
        PF_FLOAT32_RGB = 24,
        // 128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha
        PF_FLOAT32_RGBA = 25,
		// Depth stencil, 32bit depth, 8bit stencil + 24 unused
		PF_D32_S8X24 = 26,
		// Depth stencil, 24bit depth + 8bit stencil
		PF_D24S8 = 27,
		// Depth, 32bits
		PF_D32 = 28,
		// Depth, 16bits
		PF_D16 = 29,
		// Number of pixel formats currently defined
        PF_COUNT = 30
    };
	typedef Vector<PixelFormat>::type PixelFormatList;

    /**
     * Flags defining some on/off properties of pixel formats
     */
    enum PixelFormatFlags {
        // This format has an alpha channel
        PFF_HASALPHA        = 0x00000001,      
        // This format is compressed. This invalidates the values in elemBytes,
        // elemBits and the bit counts as these might not be fixed in a compressed format.
        PFF_COMPRESSED    = 0x00000002,
        // This is a floating point format
        PFF_FLOAT           = 0x00000004,         
        // This is a depth format (for depth textures)
        PFF_DEPTH           = 0x00000008,
        // Format is in native endian. Generally true for the 16, 24 and 32 bits
        // formats which can be represented as machine integers.
        PFF_NATIVEENDIAN    = 0x00000010
    };
    
    /** Pixel component format */
    enum PixelComponentType
    {
        PCT_BYTE = 0,    /// Byte per component (8 bit fixed 0.0..1.0)
        PCT_SHORT = 1,   /// Short per component (16 bit fixed 0.0..1.0))
        PCT_FLOAT16 = 2, /// 16 bit float per component
        PCT_FLOAT32 = 3, /// 32 bit float per component
        PCT_COUNT = 4    /// Number of pixel types
    };
    
	/** A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory.
     	In case of a rectangle, depth must be 1. 
     	Pixels are stored as a succession of "depth" slices, each containing "height" rows of 
     	"width" pixels.
    */
    class CM_EXPORT PixelData : public GpuResourceData
	{
    public:
    	/// Parameter constructor for setting the members manually
    	PixelData() {}
		~PixelData() {}

		/** Constructor providing extents in the form of a Box object. This constructor
    		assumes the pixel data is laid out consecutively in memory. (this
    		means row after row, slice after slice, with no space in between)
    		@param extents	    Extents of the region defined by data
    		@param pixelFormat	Format of this buffer
    		@param pixelData	Pointer to the actual data
    	*/
		PixelData(const PixelVolume &extents, PixelFormat pixelFormat)
			:mExtents(extents), mFormat(pixelFormat)
		{
			setConsecutive();
		}

    	/** Constructor providing width, height and depth. This constructor
    		assumes the pixel data is laid out consecutively in memory. (this
    		means row after row, slice after slice, with no space in between)
    		@param width	    Width of the region
    		@param height	    Height of the region
    		@param depth	    Depth of the region
    		@param pixelFormat	Format of this buffer
    		@param pixelData    Pointer to the actual data
    	*/
    	PixelData(UINT32 width, UINT32 height, UINT32 depth, PixelFormat pixelFormat)
			: mExtents(0, 0, 0, width, height, depth), mFormat(pixelFormat)
    	{
    		setConsecutive();
    	}

		PixelData(const PixelData& copy);

		UINT32 getRowPitch() const { return mRowPitch; }
		UINT32 getSlicePitch() const { return mSlicePitch; }

		void setRowPitch(UINT32 rowPitch) { mRowPitch = rowPitch; }
        void setSlicePitch(UINT32 slicePitch) { mSlicePitch = slicePitch; }

        /**	Get the number of elements between one past the rightmost pixel of 
         	one row and the leftmost pixel of the next row. (IE this is zero if rows
         	are consecutive).
        */
        UINT32 getRowSkip() const { return mRowPitch - getWidth(); }
        /** Get the number of elements between one past the right bottom pixel of
         	one slice and the left top pixel of the next slice. (IE this is zero if slices
         	are consecutive).
        */
        UINT32 getSliceSkip() const { return mSlicePitch - (getHeight() * mRowPitch); }

		PixelFormat getFormat() const { return mFormat; }

		UINT32 getWidth() const { return mExtents.getWidth(); }
		UINT32 getHeight() const { return mExtents.getHeight(); }
		UINT32 getDepth() const { return mExtents.getDepth(); }

		UINT32 getLeft() const { return mExtents.left; }
		UINT32 getRight() const { return mExtents.right; }
		UINT32 getTop() const { return mExtents.top; }
		UINT32 getBottom() const { return mExtents.bottom; }
		UINT32 getFront() const { return mExtents.front; }
		UINT32 getBack() const { return mExtents.back; }

		PixelVolume getExtents() const { return mExtents; }

        /** Return whether this buffer is laid out consecutive in memory (ie the pitches
         	are equal to the dimensions)
        */        
        bool isConsecutive() const 
		{ 
			return mRowPitch == getWidth() && mSlicePitch == getWidth()*getHeight(); 
		}
        /** Return the size (in bytes) this image would take if it was
        	laid out consecutive in memory
      	*/
      	UINT32 getConsecutiveSize() const;
      	/** Return a subvolume of this PixelBox.
      		@param def	Defines the bounds of the subregion to return
      		@returns	A pixel box describing the region and the data in it
      		@remarks	This function does not copy any data, it just returns
      			a PixelBox object with a data pointer pointing somewhere inside 
      			the data of object.
      		@throws	Exception(ERR_INVALIDPARAMS) if def is not fully contained
      	*/
      	PixelData getSubVolume(const PixelVolume &def) const;
        
        /**
         * Get colour value from a certain location in the PixelBox. The z coordinate
         * is only valid for cubemaps and volume textures. This uses the first (largest)
         * mipmap.
         */
        Color getColorAt(UINT32 x, UINT32 y, UINT32 z = 0);

        /**
         * Set colour value at a certain location in the PixelBox. The z coordinate
         * is only valid for cubemaps and volume textures. This uses the first (largest)
         * mipmap.
         */
        void setColorAt(Color const &cv, UINT32 x, UINT32 y, UINT32 z = 0);

	private:
		PixelVolume mExtents;

        /// The pixel format 
        PixelFormat mFormat;
        /** Number of elements between the leftmost pixel of one row and the left
         	pixel of the next. This value must always be equal to getWidth() (consecutive) 
			for compressed formats.
        */
        UINT32 mRowPitch;
        /** Number of elements between the top left pixel of one (depth) slice and 
         	the top left pixel of the next. This can be a negative value. Must be a multiple of
         	rowPitch. This value must always be equal to getWidth()*getHeight() (consecutive) 
			for compressed formats.
        */
        UINT32 mSlicePitch;

		/** Set the rowPitch and slicePitch so that the buffer is laid out consecutive 
         	in memory.
        */        
        void setConsecutive()
        {
            mRowPitch = getWidth();
            mSlicePitch = getWidth()*getHeight();
        }

		UINT32 getInternalBufferSize();

		/************************************************************************/
		/* 								SERIALIZATION                      		*/
		/************************************************************************/
	public:
		friend class PixelDataRTTI;
		static RTTITypeBase* getRTTIStatic();
		virtual RTTITypeBase* getRTTI() const;
    };
}