IImage.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_IMAGE_H_INCLUDED__
#define __I_IMAGE_H_INCLUDED__

#include "IReferenceCounted.h"
#include "position2d.h"
#include "rect.h"
#include "SColor.h"
#include "irrAllocator.h"
#include <string.h>

namespace irr
{
namespace video
{


class IImage : public virtual IReferenceCounted
{
public:

        IImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size, bool deleteMemory) :
                Format(format), Size(size), Data(0), MipMapsData(0), BytesPerPixel(0), Pitch(0), DeleteMemory(deleteMemory), DeleteMipMapsMemory(false)
        {
                BytesPerPixel = getBitsPerPixelFromFormat(Format) / 8;
                Pitch = BytesPerPixel * Size.Width;
        }

        virtual ~IImage()
        {
                if (DeleteMemory)
                        delete[] Data;

                if (DeleteMipMapsMemory)
                        Allocator.deallocate(MipMapsData);
        }

        ECOLOR_FORMAT getColorFormat() const
        {
                return Format;
        }

        const core::dimension2d<u32>& getDimension() const
        {
                return Size;
        }

        u32 getBitsPerPixel() const
        {

                return getBitsPerPixelFromFormat(Format);
        }

        u32 getBytesPerPixel() const
        {
                return BytesPerPixel;
        }

        u32 getImageDataSizeInBytes() const
        {
                return getDataSizeFromFormat(Format, Size.Width, Size.Height);
        }

        u32 getImageDataSizeInPixels() const
        {
                return Size.Width * Size.Height;
        }

        u32 getPitch() const
        {
                return Pitch;
        }

        u32 getRedMask() const
        {
                switch (Format)
                {
                case ECF_A1R5G5B5:
                        return 0x1F << 10;
                case ECF_R5G6B5:
                        return 0x1F << 11;
                case ECF_R8G8B8:
                        return 0x00FF0000;
                case ECF_A8R8G8B8:
                        return 0x00FF0000;
                default:
                        return 0x0;
                }
        }

        u32 getGreenMask() const
        {
                switch (Format)
                {
                case ECF_A1R5G5B5:
                        return 0x1F << 5;
                case ECF_R5G6B5:
                        return 0x3F << 5;
                case ECF_R8G8B8:
                        return 0x0000FF00;
                case ECF_A8R8G8B8:
                        return 0x0000FF00;
                default:
                        return 0x0;
                }
        }

        u32 getBlueMask() const
        {
                switch (Format)
                {
                case ECF_A1R5G5B5:
                        return 0x1F;
                case ECF_R5G6B5:
                        return 0x1F;
                case ECF_R8G8B8:
                        return 0x000000FF;
                case ECF_A8R8G8B8:
                        return 0x000000FF;
                default:
                        return 0x0;
                }
        }

        u32 getAlphaMask() const
        {
                switch (Format)
                {
                case ECF_A1R5G5B5:
                        return 0x1 << 15;
                case ECF_R5G6B5:
                        return 0x0;
                case ECF_R8G8B8:
                        return 0x0;
                case ECF_A8R8G8B8:
                        return 0xFF000000;
                default:
                        return 0x0;
                }
        }


        void* getData() const
        {
                return Data;
        }


        _IRR_DEPRECATED_ void* lock()
        {
                return getData();
        }


        _IRR_DEPRECATED_ void unlock()
        {
        }


        core::dimension2du getMipMapsSize(u32 mipmapLevel) const
        {
                return getMipMapsSize(Size, mipmapLevel);
        }



        static core::dimension2du getMipMapsSize(const core::dimension2du& sizeLevel0, u32 mipmapLevel)
        {
                core::dimension2du result(sizeLevel0);
                u32 i=0;
                while (i != mipmapLevel)
                {
                        if (result.Width>1)
                                result.Width >>= 1;
                        if (result.Height>1)
                                result.Height>>=1;
                        ++i;

                        if ( result.Width == 1 && result.Height == 1 && i < mipmapLevel )
                                return core::dimension2du(0,0);
                }
                return result;
        }



        void* getMipMapsData(irr::u32 mipLevel=1) const
        {
                if ( MipMapsData && mipLevel > 0)
                {
                        size_t dataSize = 0;
                        core::dimension2du mipSize(Size);
                        u32 i = 1;      // We want the start of data for this level, not end.

                        while (i != mipLevel)
                        {
                                if (mipSize.Width > 1)
                                        mipSize.Width >>= 1;

                                if (mipSize.Height > 1)
                                        mipSize.Height >>= 1;

                                dataSize += getDataSizeFromFormat(Format, mipSize.Width, mipSize.Height);

                                ++i;
                                if ( mipSize.Width == 1 && mipSize.Height == 1 && i < mipLevel)
                                        return 0;
                        } 

                        return MipMapsData + dataSize;
                }
        
                return 0;
        }


        void setMipMapsData(void* data, bool ownForeignMemory, bool deleteMemory)
        {
                if (data != MipMapsData)
                {
                        if (DeleteMipMapsMemory)
                        {
                                Allocator.deallocate(MipMapsData);

                                DeleteMipMapsMemory = false;
                        }

                        if (data)
                        {
                                if (ownForeignMemory)
                                {
                                        MipMapsData = static_cast<u8*>(data);

                                        DeleteMipMapsMemory = deleteMemory;
                                }
                                else
                                {
                                        u32 dataSize = 0;
                                        u32 width = Size.Width;
                                        u32 height = Size.Height;

                                        do
                                        {
                                                if (width > 1)
                                                        width >>= 1;

                                                if (height > 1)
                                                        height >>= 1;

                                                dataSize += getDataSizeFromFormat(Format, width, height);
                                        } while (width != 1 || height != 1);

                                        MipMapsData = Allocator.allocate(dataSize);
                                        memcpy(MipMapsData, data, dataSize);

                                        DeleteMipMapsMemory = true;
                                }
                        }
                        else
                        {
                                MipMapsData = 0;
                        }
                }
        }

        virtual SColor getPixel(u32 x, u32 y) const = 0;

        virtual void setPixel(u32 x, u32 y, const SColor &color, bool blend = false ) = 0;


        virtual void copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT format=ECF_A8R8G8B8, u32 pitch=0) =0;


        virtual void copyToScaling(IImage* target) =0;


        virtual void copyTo(IImage* target, const core::position2d<s32>& pos=core::position2d<s32>(0,0)) =0;


        virtual void copyTo(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect=0) =0;


        virtual void copyToWithAlpha(IImage* target, const core::position2d<s32>& pos,
                        const core::rect<s32>& sourceRect, const SColor &color,
                        const core::rect<s32>* clipRect = 0,
                        bool combineAlpha=false) =0;


        virtual void copyToScalingBoxFilter(IImage* target, s32 bias = 0, bool blend = false) = 0;

        virtual void fill(const SColor &color) =0;

        _IRR_DEPRECATED_ bool isCompressed() const
        {
                return IImage::isCompressedFormat(Format);
        }


        _IRR_DEPRECATED_ bool hasMipMaps() const
        {
                return (getMipMapsData() != 0);
        }

        static u32 getBitsPerPixelFromFormat(const ECOLOR_FORMAT format)
        {
                switch(format)
                {
                case ECF_A1R5G5B5:
                        return 16;
                case ECF_R5G6B5:
                        return 16;
                case ECF_R8G8B8:
                        return 24;
                case ECF_A8R8G8B8:
                        return 32;
                case ECF_DXT1:
                        return 16;
                case ECF_DXT2:
                case ECF_DXT3:
                case ECF_DXT4:
                case ECF_DXT5:
                        return 32;
                case ECF_PVRTC_RGB2:
                        return 12;
                case ECF_PVRTC_ARGB2:
                case ECF_PVRTC2_ARGB2:
                        return 16;
                case ECF_PVRTC_RGB4:
                        return 24;
                case ECF_PVRTC_ARGB4:
                case ECF_PVRTC2_ARGB4:
                        return 32;
                case ECF_ETC1:
                case ECF_ETC2_RGB:
                        return 24;
                case ECF_ETC2_ARGB:
                        return 32;
                case ECF_D16:
                        return 16;
                case ECF_D32:
                        return 32;
                case ECF_D24S8:
                        return 32;
                case ECF_R8:
                        return 8;
                case ECF_R8G8:
                        return 16;
                case ECF_R16:
                        return 16;
                case ECF_R16G16:
                        return 32;
                case ECF_R16F:
                        return 16;
                case ECF_G16R16F:
                        return 32;
                case ECF_A16B16G16R16F:
                        return 64;
                case ECF_R32F:
                        return 32;
                case ECF_G32R32F:
                        return 64;
                case ECF_A32B32G32R32F:
                        return 128;
                default:
                        return 0;
                }
        }

        static u32 getDataSizeFromFormat(ECOLOR_FORMAT format, u32 width, u32 height)
        {
                u32 imageSize = 0;

                switch (format)
                {
                case ECF_DXT1:
                        imageSize = ((width + 3) / 4) * ((height + 3) / 4) * 8;
                        break;
                case ECF_DXT2:
                case ECF_DXT3:
                case ECF_DXT4:
                case ECF_DXT5:
                        imageSize = ((width + 3) / 4) * ((height + 3) / 4) * 16;
                        break;
                case ECF_PVRTC_RGB2:
                case ECF_PVRTC_ARGB2:
                        imageSize = (core::max_<u32>(width, 16) * core::max_<u32>(height, 8) * 2 + 7) / 8;
                        break;
                case ECF_PVRTC_RGB4:
                case ECF_PVRTC_ARGB4:
                        imageSize = (core::max_<u32>(width, 8) * core::max_<u32>(height, 8) * 4 + 7) / 8;
                        break;
                case ECF_PVRTC2_ARGB2:
                        imageSize = core::ceil32(width / 8.0f) * core::ceil32(height / 4.0f) * 8;
                        break;
                case ECF_PVRTC2_ARGB4:
                case ECF_ETC1:
                case ECF_ETC2_RGB:
                        imageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 8;
                        break;
                case ECF_ETC2_ARGB:
                        imageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 16;
                        break;
                default: // uncompressed formats
                        imageSize = getBitsPerPixelFromFormat(format) / 8 * width;
                        imageSize *= height;
                        break;
                }

                return imageSize;
        }

        static bool isCompressedFormat(const ECOLOR_FORMAT format)
        {
                switch(format)
                {
                        case ECF_DXT1:
                        case ECF_DXT2:
                        case ECF_DXT3:
                        case ECF_DXT4:
                        case ECF_DXT5:
                        case ECF_PVRTC_RGB2:
                        case ECF_PVRTC_ARGB2:
                        case ECF_PVRTC2_ARGB2:
                        case ECF_PVRTC_RGB4:
                        case ECF_PVRTC_ARGB4:
                        case ECF_PVRTC2_ARGB4:
                        case ECF_ETC1:
                        case ECF_ETC2_RGB:
                        case ECF_ETC2_ARGB:
                                return true;
                        default:
                                return false;
                }
        }

        static bool isDepthFormat(const ECOLOR_FORMAT format)
        {
                switch(format)
                {
                        case ECF_D16:
                        case ECF_D32:
                        case ECF_D24S8:
                                return true;
                        default:
                                return false;
                }
        }

        static bool isFloatingPointFormat(const ECOLOR_FORMAT format)
        {
                if (isCompressedFormat(format))
                        return false;

                switch(format)
                {
                case ECF_R16F:
                case ECF_G16R16F:
                case ECF_A16B16G16R16F:
                case ECF_R32F:
                case ECF_G32R32F:
                case ECF_A32B32G32R32F:
                        return true;
                default:
                        break;
                }
                return false;
        }

protected:
        ECOLOR_FORMAT Format;
        core::dimension2d<u32> Size;

        u8* Data;
        u8* MipMapsData;

        u32 BytesPerPixel;
        u32 Pitch;

        bool DeleteMemory;
        bool DeleteMipMapsMemory;

        core::irrAllocator<u8> Allocator;
};

} // end namespace video
} // end namespace irr

#endif