ITexture.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_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_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_SOURCE
{
    ETS_UNKNOWN,

    ETS_FROM_CACHE,

    ETS_FROM_FILE
};
 
enum E_TEXTURE_TYPE
{
    ETT_TEXTURE_2D,
    ETT_TEXTURE_CUBE,
    ETT_TEXTURE_ARRAY,
};


class ITexture : public virtual IReferenceCounted
{
public:

    ITexture(const io::path& name) : NamedPath(name), DriverType(EDT_NULL), ColorFormat(ECF_UNKNOWN),
        Pitch(0), HasMipMaps(false), HasAlpha(false), IsRenderTarget(false), Source(ETS_UNKNOWN), TextureType(ETT_TEXTURE_2D)
    {
    }


    virtual void* lock(E_TEXTURE_LOCK_MODE mode=ETLM_READ_WRITE, u32 mipmapLevel=0) = 0;


    virtual void unlock() = 0;


    virtual void regenerateMipMapLevels(void* mipmapData = 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; };


    u32 getPitch() const { return Pitch; };


    bool hasMipMaps() const { return HasMipMaps; }

    bool hasAlpha() const { return HasAlpha; }


    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; }
 
    const E_TEXTURE_TYPE& getTextureType() const
    {
        return TextureType;
    }
 
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 ColorFormat;
    u32 Pitch;
    bool HasMipMaps;
    bool HasAlpha;
    bool IsRenderTarget;
    E_TEXTURE_SOURCE Source;
    E_TEXTURE_TYPE  TextureType;
};
 
 
} // end namespace video
} // end namespace irr
 
#endif