OgrePixelFormat.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef _PixelFormat_H__
#define _PixelFormat_H__

#include "OgrePrerequisites.h"
#include "OgreCommon.h"

namespace Ogre {
    enum PixelFormat
    {
        PF_UNKNOWN = 0,
        PF_L8 = 1,
        PF_BYTE_L = PF_L8,
        PF_L16 = 2,
        PF_SHORT_L = PF_L16,
        PF_A8 = 3,
        PF_BYTE_A = PF_A8,
        PF_A4L4 = 4,
        PF_BYTE_LA = 5,
        PF_R5G6B5 = 6,
        PF_B5G6R5 = 7,
        PF_R3G3B2 = 31,
        PF_A4R4G4B4 = 8,
        PF_A1R5G5B5 = 9,
        PF_R8G8B8 = 10,
        PF_B8G8R8 = 11,
        PF_A8R8G8B8 = 12,
        PF_A8B8G8R8 = 13,
        PF_B8G8R8A8 = 14,
        PF_R8G8B8A8 = 28,
        PF_X8R8G8B8 = 26,
        PF_X8B8G8R8 = 27,
#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
        PF_BYTE_RGB = PF_R8G8B8,
        PF_BYTE_BGR = PF_B8G8R8,
        PF_BYTE_BGRA = PF_B8G8R8A8,
        PF_BYTE_RGBA = PF_R8G8B8A8,
#else
        PF_BYTE_RGB = PF_B8G8R8,
        PF_BYTE_BGR = PF_R8G8B8,
        PF_BYTE_BGRA = PF_A8R8G8B8,
        PF_BYTE_RGBA = PF_A8B8G8R8,
#endif        
        PF_A2R10G10B10 = 15,
        PF_A2B10G10R10 = 16,
        PF_DXT1 = 17,
        PF_DXT2 = 18,
        PF_DXT3 = 19,
        PF_DXT4 = 20,
        PF_DXT5 = 21,
        // 16-bit pixel format, 16 bits (float) for red
        PF_FLOAT16_R = 32,
        // 48-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue
        PF_FLOAT16_RGB = 22,
        // 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 = 23,
        // 32-bit pixel format, 32 bits (float) for red
        PF_FLOAT32_R = 33,
        // 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,
        // 32-bit, 2-channel s10e5 floating point pixel format, 16-bit green, 16-bit red
        PF_FLOAT16_GR = 35,
        // 64-bit, 2-channel floating point pixel format, 32-bit green, 32-bit red
        PF_FLOAT32_GR = 36,
        // Depth texture format
        PF_DEPTH = 29,
        // 64-bit pixel format, 16 bits for red, green, blue and alpha
        PF_SHORT_RGBA = 30,
        // 32-bit pixel format, 16-bit green, 16-bit red
        PF_SHORT_GR = 34,
        // 48-bit pixel format, 16 bits for red, green and blue
        PF_SHORT_RGB = 37,
        PF_PVRTC_RGB2 = 38,
        PF_PVRTC_RGBA2 = 39,
        PF_PVRTC_RGB4 = 40,
        PF_PVRTC_RGBA4 = 41,
        PF_R8 = 42,
        PF_RG8 = 43,
        // Number of pixel formats currently defined
        PF_COUNT = 44
    };
    typedef vector<PixelFormat>::type PixelFormatList;

    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,
        // This is an intensity format instead of a RGB one. The luminance
        // replaces R,G and B. (but not A)
        PFF_LUMINANCE       = 0x00000020
    };
    
    enum PixelComponentType
    {
        PCT_BYTE = 0,    
        PCT_SHORT = 1,   
        PCT_FLOAT16 = 2, 
        PCT_FLOAT32 = 3, 
        PCT_COUNT = 4    
    };
    
    class _OgreExport PixelBox: public Box, public ImageAlloc {
    public:
        PixelBox() {}
        ~PixelBox() {}
        PixelBox(const Box &extents, PixelFormat pixelFormat, void *pixelData=0):
            Box(extents), data(pixelData), format(pixelFormat)
        {
            setConsecutive();
        }
        PixelBox(size_t width, size_t height, size_t depth, PixelFormat pixelFormat, void *pixelData=0):
            Box(0, 0, 0, width, height, depth),
            data(pixelData), format(pixelFormat)
        {
            setConsecutive();
        }
        
        void *data;
        PixelFormat format;
        size_t rowPitch;
        size_t slicePitch;
        
        void setConsecutive()
        {
            rowPitch = getWidth();
            slicePitch = getWidth()*getHeight();
        }
        size_t getRowSkip() const { return rowPitch - getWidth(); }
        size_t getSliceSkip() const { return slicePitch - (getHeight() * rowPitch); }

        bool isConsecutive() const 
        { 
            return rowPitch == getWidth() && slicePitch == getWidth()*getHeight(); 
        }
        size_t getConsecutiveSize() const;
        PixelBox getSubVolume(const Box &def) const;
        
        ColourValue getColourAt(size_t x, size_t y, size_t z);

        void setColourAt(ColourValue const &cv, size_t x, size_t y, size_t z);
    };
    

    class _OgreExport PixelUtil {
    public:
        static size_t getNumElemBytes( PixelFormat format );

        static size_t getNumElemBits( PixelFormat format );

        static size_t getMemorySize(size_t width, size_t height, size_t depth, PixelFormat format);
        
        static unsigned int getFlags( PixelFormat format );

        static bool hasAlpha(PixelFormat format);
        static bool isFloatingPoint(PixelFormat format);
        static bool isCompressed(PixelFormat format);
        static bool isDepth(PixelFormat format);
        static bool isNativeEndian(PixelFormat format);
        static bool isLuminance(PixelFormat format);
        
        static bool isValidExtent(size_t width, size_t height, size_t depth, PixelFormat format);

        static void getBitDepths(PixelFormat format, int rgba[4]);

        static void getBitMasks(PixelFormat format, uint32 rgba[4]);

        static void getBitShifts(PixelFormat format, unsigned char rgba[4]);

        static String getFormatName(PixelFormat srcformat);

        static bool isAccessible(PixelFormat srcformat);
        
        static PixelComponentType getComponentType(PixelFormat fmt);
        
        static size_t getComponentCount(PixelFormat fmt);

        static PixelFormat getFormatFromName(const String& name, bool accessibleOnly = false, bool caseSensitive = false);

        static String getBNFExpressionOfPixelFormats(bool accessibleOnly = false);

        static PixelFormat getFormatForBitDepths(PixelFormat fmt, ushort integerBits, ushort floatBits);

        static void packColour(const ColourValue &colour, const PixelFormat pf,  void* dest);
        static void packColour(const uint8 r, const uint8 g, const uint8 b, const uint8 a, const PixelFormat pf,  void* dest);
        static void packColour(const float r, const float g, const float b, const float a, const PixelFormat pf,  void* dest);

        static void unpackColour(ColourValue *colour, PixelFormat pf,  const void* src);
        static void unpackColour(uint8 *r, uint8 *g, uint8 *b, uint8 *a, PixelFormat pf,  const void* src);
        static void unpackColour(float *r, float *g, float *b, float *a, PixelFormat pf,  const void* src); 
        
        static void bulkPixelConversion(void *src, PixelFormat srcFormat, void *dest, PixelFormat dstFormat, unsigned int count);

        static void bulkPixelConversion(const PixelBox &src, const PixelBox &dst);
    };
}

#endif