enum TPixelFormat
{
    PXF_L8,       ///< Luminosité 8 bits
    PXF_A8L8,     ///< Alpha et luminosité 16 bits
    PXF_A1R5G5B5, ///< ARGB 16 bits 1555
    PXF_A4R4G4B4, ///< ARGB 16 bits 4444
    PXF_R8G8B8,   ///< RGB 24 bits 888
    PXF_A8R8G8B8, ///< ARGB 32 bits 8888
    PXF_DXTC1,    ///< Format compressé DXT1 8 bits
    PXF_DXTC3,    ///< Format compressé DXT3 16 bits
    PXF_DXTC5     ///< Format compressé DXT5 16 bits
};

template <TPixelFormat SrcFmt, TPixelFormat DestFmt>
inline void ConvertPixel(const unsigned char* Src, unsigned char* Dest)
{
    // Comportement par défaut : si la spécialisation n'existe pas
    // c'est que la conversion n'est pas prise en charge
    throw CUnsupported(std::string("Conversion software de format de pixel (") +
                       FormatToString(SrcFmt) +
                       " -> " +
                       FormatToString(DestFmt) +
                       ")");
}

template <>
inline void ConvertPixel<PXF_L8, PXF_L8>(const unsigned char* Src, unsigned char* Dest)
{
    *Dest = *Src;
}

template <>
inline void ConvertPixel<PXF_L8, PXF_A8L8>(const unsigned char* Src, unsigned char* Dest)
{
    Dest[0] = *Src;
    Dest[1] = 0xFF;
}

...

template <>
inline void ConvertPixel<PXF_A8L8, PXF_A1R5G5B5>(const unsigned char* Src, unsigned char* Dest)
{
    *reinterpret_cast<unsigned short*>(Dest) = ((Src[1] >> 7) << 15) |
                                               ((Src[0] >> 3) << 10) |
                                               ((Src[0] >> 3) <<  5) |
                                               ((Src[0] >> 3) <<  0);
}

template <>
inline void ConvertPixel<PXF_A8L8, PXF_A4R4G4B4>(const unsigned char* Src, unsigned char* Dest)
{
    Dest[0] = (Src[0] & 0xF0) | (Src[0] >> 4);
    Dest[1] = (Src[1] & 0xF0) | (Src[0] >> 4);
}


...

// 6 formats : 6x6 = 36 spécialisations
// (les formats compressés ne sont pas pris en charge, c'est impossible avec cette stratégie :
// il faut les traiter par blocs de 2x2 pixels)

inline void ConvertPixel(TPixelFormat SrcFmt, const unsigned char* Src,
                         TPixelFormat DestFmt, unsigned char* Dest)
{
    // Définition d'une macro évitant d'avoir un code de 50 000 lignes de long
    #define CONVERSIONS_FOR(Fmt) \
        case Fmt : \
        { \
            switch (DestFmt) \
            { \
                case PXF_L8 :       ConvertPixel<Fmt, PXF_L8>(Src, Dest);       break; \
                case PXF_A8L8 :     ConvertPixel<Fmt, PXF_A8L8>(Src, Dest);     break; \
                case PXF_A1R5G5B5 : ConvertPixel<Fmt, PXF_A1R5G5B5>(Src, Dest); break; \
                case PXF_A4R4G4B4 : ConvertPixel<Fmt, PXF_A4R4G4B4>(Src, Dest); break; \
                case PXF_R8G8B8 :   ConvertPixel<Fmt, PXF_R8G8B8>(Src, Dest);   break; \
                case PXF_A8R8G8B8 : ConvertPixel<Fmt, PXF_A8R8G8B8>(Src, Dest); break; \
                case PXF_DXTC1 :    ConvertPixel<Fmt, PXF_DXTC1>(Src, Dest);    break; \
                case PXF_DXTC3 :    ConvertPixel<Fmt, PXF_DXTC3>(Src, Dest);    break; \
                case PXF_DXTC5 :    ConvertPixel<Fmt, PXF_DXTC5>(Src, Dest);    break; \
            } \
            break; \
        }

    // Gestion de la conversion - appelle la version optimisée de la conversion
    // pour les deux formats mis en jeu
    switch (SrcFmt)
    {
        CONVERSIONS_FOR(PXF_L8)
        CONVERSIONS_FOR(PXF_A8L8)
        CONVERSIONS_FOR(PXF_A1R5G5B5)
        CONVERSIONS_FOR(PXF_A4R4G4B4)
        CONVERSIONS_FOR(PXF_R8G8B8)
        CONVERSIONS_FOR(PXF_A8R8G8B8)
        CONVERSIONS_FOR(PXF_DXTC1)
        CONVERSIONS_FOR(PXF_DXTC3)
        CONVERSIONS_FOR(PXF_DXTC5)
    }

    // On tue la macro une fois qu'on n'en a plus besoin
    #undef CONVERIONS_FOR
}

class YES_EXPORT CImage
{
private :

    TVector2I                  m_Size;
    TPixelFormat               m_Format;
    std::vector<unsigned char> m_Pixels;

public :

    CImage(const TVector2I& Size = TVector2I(1, 1), TPixelFormat Format = PXF_A8R8G8B8);
    CImage(const TVector2I& Size, TPixelFormat Format, const unsigned char* Pixels);

    const TVector2I& GetSize() const;
    TPixelFormat GetFormat() const;
    const unsigned char* GetData() const;

    void SetPixel(int x, int y, const unsigned char* Pix);
    void SetPixel(int x, int y, const CColor& Color);
    void GetPixel(int x, int y, unsigned char* Pix) const;
    CColor GetPixel(int x, int y) const;

    void CopyImage(const CImage& Src);
    CImage SubImage(const CRectangle& Rect) const;
    void Fill(const CColor& Color);
    void Flip();
    void Mirror();
};

dlltool -D Devil.dll -d il.def -l libil.a

class CImagesLoader : public ILoader<CImage>
{
public :

    // Constructeur par défaut
    CImagesLoader();

    // Destructeur
    ~CImagesLoader();

    // Charge une image à partir d'un fichier
    virtual CImage* LoadFromFile(const std::string& Filename);

    // Enregistre une image dans un fichier
    virtual void SaveToFile(const CImage* Object, const std::string& Filename);
};

CImagesLoader::CImagesLoader()
{
    // Initalisation de DevIL
    ilInit();

    // On indique que l'origine des images se trouve sur le coin haut-gauche
    ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
    ilEnable(IL_ORIGIN_SET);

    // On autorise l'écrasement de fichiers déjà existants, pour la sauvegarde
    ilEnable(IL_FILE_OVERWRITE);

    // On force le chargement des images en 32 bits BGRA
    ilSetInteger(IL_FORMAT_MODE, IL_BGRA);
    ilEnable(IL_FORMAT_SET);
}

CImagesLoader::~CImagesLoader()
{
    // Fermeture de DevIL
    ilShutDown();
}

CImage* CImagesLoader::LoadFromFile(const std::string& Filename)
{
    // Génération d'une nouvelle texture
    ILuint Texture;
    ilGenImages(1, &Texture);
    ilBindImage(Texture);

    // Chargement de l'image
    if (!ilLoadImage(const_cast<ILstring>(Filename.c_str())))
        throw CLoadingFailed(Filename, "Erreur DevIL : l'appel à ilLoadImage a échoué");

    // Récupération de la taille de l'image
    TVector2I Size(ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT));

    // Récupération des pixels de l'image
    const unsigned char* Pixels = ilGetData();

    // Création de l'image
    CImage* Image = new CImage(Size, PXF_A8R8G8B8, Pixels);

    // Suppression de la texture
    ilBindImage(0);
    ilDeleteImages(1, &Texture);

    // On log le chargement
    ILogger::Log() << "Chargement de l'image : " << Filename << "\n";

    return Image;
}

void CImagesLoader::SaveToFile(const CImage* Object, const std::string& Filename)
{
    // On crée une copie de l'image dans un format compatible avec DevIL (ARGB 32 bits)
    CImage Image(Object->GetSize(), PXF_A8R8G8B8);
    Image.CopyImage(*Object);

    // On retourne l'image, sans quoi elle apparaîtrait à l'envers
    Image.Flip();

    // Génération d'une nouvelle texture
    ILuint Texture;
    ilGenImages(1, &Texture);
    ilBindImage(Texture);

    // Récupération des dimensions de l'image
    const TVector2I& Size = Image.GetSize();

    // Dimensionnement et remplissage de la texture avec les pixels convertis
    if (!ilTexImage(Size.x, Size.y, 1, GetBytesPerPixel(Image.GetFormat()),
                    IL_BGRA, IL_UNSIGNED_BYTE, (void*)Image.GetData()))
        throw CLoadingFailed(Filename, "Erreur DevIL : l'appel à ilTexImage a échoué");

    // Sauvegarde de la texture
    if (!ilSaveImage(const_cast<ILstring>(Filename.c_str())))
        throw CLoadingFailed(Filename, "Erreur DevIL : l'appel à ilSaveImage a échoué");

    // Suppression de la texture
    ilBindImage(0);
    ilDeleteImages(1, &Texture);

    // On log la sauvegarde
    ILogger::Log() << "Sauvegarde de l'image : " << Filename << "\n";
}

// Quelque part dans les initialisations du moteur...
CMediaManager& MediaManager = CMediaManager::Instance();
MediaManager.RegisterLoader(new CImagesLoader, "bmp, dds, jpg, pcx, png, pnm, raw, sgi, tga, tif");

// Liste des medias gérés (d'autres s'ajouteront par la suite)
typedef TYPELIST_1(CImage) MediaList;

class CMediaManager : public CSingleton<CMediaManager>,
                      public CScatteredHierarchy<MediaList, CMediaHolder>
{
    ...
};

class YES_EXPORT ITextureBase : public IResource
{
public :

    // Destructeur
    virtual ~ITextureBase();

protected :

    // Amis
    friend class CTexture;

    // Constructeur
    ITextureBase(const TVector2I& Size, TPixelFormat Format, bool HasMipmaps, bool AutoMipmaps);

    // Met à jour les pixels de la texture
    virtual void Update(const CRectangle& Rect) = 0;

    // Données membres
    TPixelFormat m_Format;      ///< Format de pixel de la texture
    TVector2I    m_Size;        ///< Dimensions de la texture
    CImage       m_Data;        ///< Copie système du contenu de la texture
    bool         m_HasMipmaps;  ///< Indique si la texture possède des niveaux de mipmapping
    bool         m_AutoMipmaps; ///< Indique si la texture peut générer ses mips en hardware
};

ITextureBase* COGLRenderer::CreateTexture(const TVector2I& Size, TPixelFormat Format,
                                          unsigned long Flags) const
{
    unsigned int Texture;
    glGenTextures(1, &Texture);
    glBindTexture(GL_TEXTURE_2D, Texture);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);

    // Détermination du nombre de niveaux de mipmapping
    int NbMipmaps = Flags & TEX_NOMIPMAP ? GetNbMipLevels(Size.x, Size.y) : 0;
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, NbMipmaps);

    // S'il y a plusieurs niveaux de mipmaps et si le système le supporte,
    // on active la génération hardware des mipmaps
    if ((NbMipmaps > 0) && (HasCapability(CAP_HW_MIPMAPPING)))
        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);

    // Allocation de la mémoire pour tous les niveaux de mipmapping
    int Width  = Size.x;
    int Height = Size.y;
    for (int i = 0; i <= NbMipmaps; ++i)
    {
        // Création du i-ème niveau
        glTexImage2D(GL_TEXTURE_2D, i, COGLEnum::Get(Format).Internal,
                     Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

        // Division par 2 des dimensions
        if (Width > 1)  Width  /= 2;
        if (Height > 1) Height /= 2;
    }

    // Désactivation de la texture
    glBindTexture(GL_TEXTURE_2D, 0);

    return new COGLTexture(Size, Format, NbMipmaps > 0,
                           HasCapability(CAP_HW_MIPMAPPING), Texture);
}

void COGLRenderer::SetTexture(unsigned int Unit, const ITextureBase* Texture) const
{
    glActiveTextureARB(GL_TEXTURE0_ARB + Unit);
    const COGLTexture* OGLTexture = static_cast<const COGLTexture*>(Texture);

    if (Texture)
    {
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, OGLTexture->GetOGLTexture());
    }
    else
    {
        glDisable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, 0);
    }
}

ITextureBase* CDX9Renderer::CreateTexture(const TVector2I& Size, TPixelFormat Format,
                                          unsigned long Flags) const
{
    // Détection du nombre de niveaux de mips et du mipmapping automatique
    bool HasMipmaps  = (Flags & TEX_NOMIPMAP) != 0;
    bool AutoMipmaps = HasCapability(CAP_HW_MIPMAPPING) &&
                       m_Direct3D->CheckDeviceFormat(D3DADAPTER_DEFAULT,
                                                     D3DDEVTYPE_HAL,
                                                     D3DFMT_X8R8G8B8,
                                                     D3DUSAGE_AUTOGENMIPMAP,
                                                     D3DRTYPE_TEXTURE,
                                                     CDX9Enum::Get(Format)) != D3D_OK;

    // Ajustement de l'usage
    unsigned long Usage = AutoMipmaps ? D3DUSAGE_AUTOGENMIPMAP : 0;

    // Création de la texture Dx9
    LPDIRECT3DTEXTURE9 Texture = NULL;
    if (FAILED(D3DXCreateTexture(m_Device, Size.x, Size.y, 0, Usage,
                                 CDX9Enum::Get(Format), D3DPOOL_MANAGED, &Texture)))
        throw CDX9Exception("D3DXCreateTexture", "CreateTexture");

    return new CDX9Texture(Size, Format, HasMipmaps, AutoMipmaps, Texture);
}

void CDX9Renderer::SetTexture(unsigned int Unit, const ITextureBase* Texture) const
{
    const CDX9Texture* DxTexture = static_cast<const CDX9Texture*>(Texture);
    m_Device->SetTexture(Unit, DxTexture ? DxTexture->GetDxTexture() : NULL);
}

class YES_EXPORT CTexture
{
private :

    // Données membres
    CSmartPtr<ITextureBase, CResourceCOM> m_Texture; ///< Pointeur sur la texture

public :

    // Opérateurs de comparaison
    bool operator ==(const CTexture& Texture) const;
    bool operator !=(const CTexture& Texture) const;

    // Accesseurs
    CImage& GetPixels();
    const TVector2I& GetSize() const;
    TPixelFormat GetFormat() const;
    const std::string& GetName() const;
    const ITextureBase* GetTexture() const;

    // Crée la texture
    void Create(const TVector2I& Size, TPixelFormat Format,
                unsigned long Flags = 0, const std::string& Name = "");

    // Crée la texture à partir d'un fichier
    void CreateFromFile(const std::string& Filename, TPixelFormat Format,
                        unsigned long Flags = 0);

    // Crée la texture à partir d'une image
    void CreateFromImage(const CImage& Image, TPixelFormat Format,
                         unsigned long Flags = 0, const std::string& Name = "");

    // Sauvegarde la texture dans un fichier
    void SaveToFile(const std::string& Filename) const;

    // Met à jour les pixels de la texture
    void Update(const CRectangle& Rect = CRectangle(-1, -1, -1, -1));
    
private :

    // Crée la texture et la remplit avec les pixels passés en paramètre
    void Load(const CImage& Image, TPixelFormat Format,
              unsigned long Flags, const std::string& Name);
};

void CTexture::Load(const CImage& Pixels, TPixelFormat Format,
                    unsigned long Flags, const std::string& Name)
{
    // Si le format est compressé et que la compression n'est pas supportée,
    // on passe à un format standard (PXF_A8R8G8B8)
    if (FormatCompressed(Format) && !Renderer.HasCapability(CAP_DXT_COMPRESSION))
    {
        Format = PXF_A8R8G8B8;
        ILogger::Log() << "WARNING - "
                       << "Format compressé choisi, mais non supporté par le système de rendu. "
                       << "Le format utilisé sera PXF_A8R8G8B8."
                       << (Name != "" ? " (texture : \"" + Name + "\")" : "") << "\n";
    }

    // Si le système requiert des dimensions en puissances de 2 et que ce n'est pas le cas,
    // on modifie celles-ci
    TVector2I Size(NearestPowerOfTwo(Pixels.GetSize().x), NearestPowerOfTwo(Pixels.GetSize().y));
    if ((Size != Pixels.GetSize()) && !Renderer.HasCapability(CAP_TEX_NON_POWER_2))
    {
        ILogger::Log() << "WARNING - Dimensions de texture non-puissances de 2, "
                       << "mais non supporté par le système de rendu. "
                       << "Les dimensions seront ajustées. "
                       << "(" << Pixels.GetSize().x << "x" << Pixels.GetSize().y
                       << " -> " << Size.x << "x" << Size.y << ")" << "\n";
    }
    else
    {
        Size = Pixels.GetSize();
    }


    try
    {
        // Création de la texture
        m_Texture = Renderer.CreateTexture(Size, Format, Flags);
    }
    catch (const std::exception& E)
    {
        // IRenderer::CreateTexture ne connait pas le nom de la texture,
        // ainsi si l'on veut mieux renseigner l'utilisateur il faut rattraper
        // les exceptions et en relancer une plus appropriée (avec le nom inside)
        throw CLoadingFailed(Name, E.what());
    }

    // Ajout aux ressources
    if (Name != "")
        CResourceManager::Instance().Add(Name, m_Texture);

    // Si le format est compressé on change le format de la copie système de la
    // texture (PXF_A8R8G8B8) -- la compression software n'est pas supportée par le moteur
    if (FormatCompressed(Format))
        GetPixels() = CImage(GetSize(), PXF_A8R8G8B8);

    // Copie des pixels
    GetPixels().CopyImage(Pixels);
    Update();
}

void CTexture::Create(const TVector2I& Size, TPixelFormat Format,
                      unsigned long Flags, const std::string& Name)
{
    // Création de la texture vide --
    // afin qu'elle ait un contenu valide on la remplit avec une image par défaut
    CreateFromImage(CImage(Size, Format), Format, Flags, Name);
}

void CTexture::CreateFromFile(const std::string& Filename, TPixelFormat Format,
                              unsigned long Flags)
{
    // On regarde si la texture n'a pas déjà été chargée
    m_Texture = CResourceManager::Instance().Get<ITextureBase>(Filename);

    // Si elle ne l'est pas, on la charge
    if (!m_Texture)
    {
        // Chargement de l'image
        CSmartPtr<CImage> Image = CMediaManager::Instance().LoadMediaFromFile<CImage>(Filename);

        // Création de la texture
        Load(*Image, Format, Flags, Filename);
    }
}

void CTexture::CreateFromImage(const CImage& Image, TPixelFormat Format,
                               unsigned long Flags, const std::string& Name)
{
    // On regarde si la texture n'a pas déjà été chargée
    m_Texture = CResourceManager::Instance().Get<ITextureBase>(Name);

    // Si elle ne l'est pas, on la charge
    if (!m_Texture)
       Load(Image, Format, Flags, Name);
}

enum TCapability
{
    CAP_HW_MIPMAPPING,   ///< Mipmapping automatique en hardware
    CAP_DXT_COMPRESSION, ///< Compression de texture DXTC
    CAP_TEX_NON_POWER_2, ///< Dimensions de textures pas nécessairement en puissances de 2
};

class YES_EXPORT IRenderer
{
public :

    // ...

    // Indique si une fonctionnalité est supportée par le renderer
    bool HasCapability(TCapability Cap) const;

protected :

    // Vérifie les fonctionnalités supportées et met à jour la table des fonctionnalités
    virtual void CheckCaps() = 0;

    // Données membres
    std::map<TCapability, bool> m_Capabilities; ///< Table des fonctionnalités

    // ...
};

bool IRenderer::HasCapability(TCapability Cap) const
{
    // Ici on ne peut pas utiliser l'opérateur [], bicoze on se trouve dans une fonction const

    Assert(m_Capabilities.find(Cap) != m_Capabilities.end());

    return m_Capabilities.find(Cap)->second;
}

void CDX9Renderer::CheckCaps()
{
    // Récupération des caps Dx9
    D3DCAPS9 Caps;
    m_Device->GetDeviceCaps(&Caps);

    // Support de la génération de mipmaps hardware
    m_Capabilities[CAP_HW_MIPMAPPING] = (Caps.Caps2 & D3DCAPS2_CANAUTOGENMIPMAP) != 0;

    // Support de la compression de texture
    m_Capabilities[CAP_DXT_COMPRESSION] = CheckFormat(D3DFMT_DXT1, D3DRTYPE_TEXTURE) &&
                                          CheckFormat(D3DFMT_DXT3, D3DRTYPE_TEXTURE) &&
                                          CheckFormat(D3DFMT_DXT5, D3DRTYPE_TEXTURE);

    // Support des dimensions de texture non-puissances de 2
    m_Capabilities[CAP_TEX_NON_POWER_2] = !(Caps.TextureCaps & D3DPTEXTURECAPS_POW2) &&
                                          !(Caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL);
}

bool CDX9Renderer::CheckFormat(D3DFORMAT Format, D3DRESOURCETYPE ResourceType, unsigned long Usage)
{
    Assert(m_Direct3D != NULL);

    return SUCCEEDED(m_Direct3D->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
                                                   D3DFMT_X8R8G8B8,
                                                   Usage, ResourceType, Format));
}

void COGLRenderer::CheckCaps()
{
    // Support de la génération de mipmaps hardware
    m_Capabilities[CAP_HW_MIPMAPPING] = CheckExtension("GL_SGIS_generate_mipmap");

    // Support de la compression de texture
    m_Capabilities[CAP_DXT_COMPRESSION] = CheckExtension("GL_ARB_texture_compression") &&
                                          CheckExtension("GL_EXT_texture_compression_s3tc");

    // Support des dimensions de texture non-puissances de 2
    m_Capabilities[CAP_TEX_NON_POWER_2] = CheckExtension("GL_ARB_texture_non_power_of_two");
}

bool COGLRenderer::CheckExtension(const std::string& Extension) const
{
    return m_Extensions.find(Extension) != std::string::npos;
}

// Déclaration de la texture
CTexture Texture;

// Chargement de l'image
Texture.CreateFromFile("Mouton.dds", PXF_DXTC5);

// On va changer un pixel, juste pour le fun
CImage& Pixels = Texture.GetPixels();
Pixels.SetPixel(0, 0, CColor(0, 128, 128));
Texture.Update();

// Finalement, on peut l'envoyer à l'API pour le rendu
Renderer.SetTexture(0, &Texture);

// Tiens, et pourquoi pas en monochrome et en plus petit ?
CTexture NewTexture;
CImage NewImage(TVector2I(64, 64), PXF_L8);
NewImage.CopyImage(Texture.GetPixels());
NewTexture.CreateFromImage(NewImage, PXF_L8);