ITexture.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_I_TEXTURE_HPP_INCLUDED
#define NIRT_I_TEXTURE_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IReferenceCounted.hpp>
#include <nirtcpp/core/engine/IImage.hpp>
#include <nirtcpp/core/engine/dimension2d.hpp>
#include <nirtcpp/core/engine/EDriverTypes.hpp>
#include <nirtcpp/core/engine/path.hpp>
#include <nirtcpp/core/engine/matrix4.hpp>
 
namespace nirt
{
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_SUPPORT_VERTEXT_TEXTURE = 0x00000200,
 
    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 nirt
 
#endif