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-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#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,
        // 16-bit pixel format, 16 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,
        // Depth texture format
        PF_DEPTH = 29,
        // 64-bit pixel format, 16 bits for red, green, blue and alpha
        PF_SHORT_RGBA = 30,
        // Number of pixel formats currently defined
        PF_COUNT = 34
    };

    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
    };
    class _OgreExport PixelBox: public Box {
    public:
        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;
    };
    

    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 String getFormatName(PixelFormat srcformat);

        static bool isAccessible(PixelFormat srcformat);
        
        static void packColour(const ColourValue &colour, const PixelFormat pf,  const void* dest);
        static void packColour(const uint8 r, const uint8 g, const uint8 b, const uint8 a, const PixelFormat pf,  const void* dest);
        static void packColour(const float r, const float g, const float b, const float a, const PixelFormat pf,  const 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

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:50 2006