ITexture.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_TEXTURE_H_INCLUDED__
#define __I_TEXTURE_H_INCLUDED__

#include "IReferenceCounted.h"
#include "IImage.h"
#include "dimension2d.h"
#include "EDriverTypes.h"
#include "path.h"
#include "matrix4.h"

namespace irr
{
namespace video
{


enum E_TEXTURE_CREATION_FLAG
{
        ETCF_ALWAYS_16_BIT = 0x00000001,

        ETCF_ALWAYS_32_BIT = 0x00000002,

        ETCF_OPTIMIZED_FOR_QUALITY = 0x00000004,

        ETCF_OPTIMIZED_FOR_SPEED = 0x00000008,

        ETCF_CREATE_MIP_MAPS = 0x00000010,

        ETCF_NO_ALPHA_CHANNEL = 0x00000020,


        ETCF_ALLOW_NON_POWER_2 = 0x00000040,


        ETCF_ALLOW_MEMORY_COPY = 0x00000080,


        ETCF_AUTO_GENERATE_MIP_MAPS = 0x00000100,

        ETCF_FORCE_32_BIT_DO_NOT_USE = 0x7fffffff
};

enum E_TEXTURE_LOCK_MODE
{
        ETLM_READ_WRITE = 0,


        ETLM_READ_ONLY,


        ETLM_WRITE_ONLY
};

enum E_TEXTURE_LOCK_FLAGS
{
        ETLF_NONE = 0,


        ETLF_FLIP_Y_UP_RTT = 1  
};

enum E_TEXTURE_SOURCE
{
        ETS_UNKNOWN,

        ETS_FROM_CACHE,

        ETS_FROM_FILE
};

enum E_TEXTURE_TYPE
{
        ETT_2D,

        ETT_CUBEMAP
};


class ITexture : public virtual IReferenceCounted
{
public:

        ITexture(const io::path& name, E_TEXTURE_TYPE type) : NamedPath(name), DriverType(EDT_NULL), OriginalColorFormat(ECF_UNKNOWN),
                ColorFormat(ECF_UNKNOWN), Pitch(0), HasMipMaps(false), IsRenderTarget(false), Source(ETS_UNKNOWN), Type(type)
        {
        }


        virtual void* lock(E_TEXTURE_LOCK_MODE mode = ETLM_READ_WRITE, u32 mipmapLevel=0, u32 layer = 0, E_TEXTURE_LOCK_FLAGS lockFlags = ETLF_FLIP_Y_UP_RTT) = 0;


        virtual void unlock() = 0;


        virtual void regenerateMipMapLevels(void* data = 0, u32 layer = 0) = 0;


        const core::dimension2d<u32>& getOriginalSize() const { return OriginalSize; };


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


        E_DRIVER_TYPE getDriverType() const { return DriverType; };


        ECOLOR_FORMAT getColorFormat() const { return ColorFormat; };


        ECOLOR_FORMAT getOriginalColorFormat() const { return OriginalColorFormat; };


        u32 getPitch() const { return Pitch; };


        bool hasMipMaps() const { return HasMipMaps; }


        bool isRenderTarget() const { return IsRenderTarget; }

        const io::SNamedPath& getName() const { return NamedPath; }

        E_TEXTURE_SOURCE getSource() const { return Source; }

        void updateSource(E_TEXTURE_SOURCE source) { Source = source; }

        bool hasAlpha() const
        {
                bool status = false;

                switch (ColorFormat)
                {
                case ECF_A8R8G8B8:
                case ECF_A1R5G5B5:
                case ECF_DXT1:
                case ECF_DXT2:
                case ECF_DXT3:
                case ECF_DXT4:
                case ECF_DXT5:
                case ECF_A16B16G16R16F:
                case ECF_A32B32G32R32F:
                        status = true;
                        break;
                default:
                        break;
                }

                return status;
        }

        E_TEXTURE_TYPE getType() const { return Type; }

protected:


        inline E_TEXTURE_CREATION_FLAG getTextureFormatFromFlags(u32 flags)
        {
                if (flags & ETCF_OPTIMIZED_FOR_SPEED)
                        return ETCF_OPTIMIZED_FOR_SPEED;
                if (flags & ETCF_ALWAYS_16_BIT)
                        return ETCF_ALWAYS_16_BIT;
                if (flags & ETCF_ALWAYS_32_BIT)
                        return ETCF_ALWAYS_32_BIT;
                if (flags & ETCF_OPTIMIZED_FOR_QUALITY)
                        return ETCF_OPTIMIZED_FOR_QUALITY;
                return ETCF_OPTIMIZED_FOR_SPEED;
        }

        io::SNamedPath NamedPath;
        core::dimension2d<u32> OriginalSize;
        core::dimension2d<u32> Size;
        E_DRIVER_TYPE DriverType;
        ECOLOR_FORMAT OriginalColorFormat;
        ECOLOR_FORMAT ColorFormat;
        u32 Pitch;
        bool HasMipMaps;
        bool IsRenderTarget;
        E_TEXTURE_SOURCE Source;
        E_TEXTURE_TYPE Type;
};


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

#endif