IImage.h

// 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"
 
namespace irr
{
namespace video
{


class IImage : public virtual IReferenceCounted
{
public:


    virtual void* lock() = 0;


    virtual void unlock() = 0;

    virtual const core::dimension2d<u32>& getDimension() const = 0;

    virtual u32 getBitsPerPixel() const = 0;

    virtual u32 getBytesPerPixel() const = 0;

    virtual u32 getImageDataSizeInBytes() const = 0;

    virtual u32 getImageDataSizeInPixels() const = 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 ECOLOR_FORMAT getColorFormat() const = 0;

    virtual u32 getRedMask() const = 0;

    virtual u32 getGreenMask() const = 0;

    virtual u32 getBlueMask() const = 0;

    virtual u32 getAlphaMask() const = 0;

    virtual u32 getPitch() const =0;

    virtual void copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT format=ECF_A8R8G8B8, u32 pitch=0, bool swapBG=false) =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) =0;

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

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

    virtual bool isCompressed() const = 0;


    virtual bool hasMipMaps() const = 0;
 
    virtual void swapBG() = 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_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 getCompressedImageSize(ECOLOR_FORMAT format, u32 width, u32 height)
    {
        if (!isCompressedFormat(format))
            return 0;
 
        u32 compressedImageSize = 0;
 
        switch (format)
        {
        case ECF_DXT1:
            compressedImageSize = ((width + 3) / 4) * ((height + 3) / 4) * 8;
            break;
        case ECF_DXT2:
        case ECF_DXT3:
        case ECF_DXT4:
        case ECF_DXT5:
            compressedImageSize = ((width + 3) / 4) * ((height + 3) / 4) * 16;
            break;
        case ECF_PVRTC_RGB2:
        case ECF_PVRTC_ARGB2:
            compressedImageSize = (core::max_<u32>(width, 16) * core::max_<u32>(height, 8) * 2 + 7) / 8;
            break;
        case ECF_PVRTC_RGB4:
        case ECF_PVRTC_ARGB4:
            compressedImageSize = (core::max_<u32>(width, 8) * core::max_<u32>(height, 8) * 4 + 7) / 8;
            break;
        case ECF_PVRTC2_ARGB2:
            compressedImageSize = core::ceil32(width / 8.0f) * core::ceil32(height / 4.0f) * 8;
            break;
        case ECF_PVRTC2_ARGB4:
        case ECF_ETC1:
        case ECF_ETC2_RGB:
            compressedImageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 8;
            break;
        case ECF_ETC2_ARGB:
            compressedImageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 16;
            break;
        case ECT_PVRTC2_RGBA4444:
        case ECT_PVRTC2_RGB565:
            compressedImageSize = width * height * 2;
            break;
        case ECT_PVRTC2_RGB888:
            compressedImageSize = width * height * 3;
            break;
        case ECT_PVRTC2_RGBA8888:
            compressedImageSize = width * height * 4;
            break;
        default:
            break;
        }
 
        return compressedImageSize;
    }

    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:
        case ECT_PVRTC2_RGBA4444:
        case ECT_PVRTC2_RGB565:
        case ECT_PVRTC2_RGB888:
        case ECT_PVRTC2_RGBA8888:
            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 isRenderTargetOnlyFormat(const ECOLOR_FORMAT format)
    {
        switch(format)
        {
            case ECF_A1R5G5B5:
            case ECF_R5G6B5:
            case ECF_R8G8B8:
            case ECF_A8R8G8B8:
                return false;
            default:
                return true;
        }
    }
 
};
 
} // end namespace video
} // end namespace irr
 
#endif