gltexture.h

Go to the documentation of this file.

#pragma once
#include <adtf_base.h>
#include <adtfdisplaytoolboxgraphics/image.h>
#include <adtfdisplaytoolboxgraphics/gfxlibinterfaces.h>
 
// Needed for static CalcOpenGLTextureFormat() param types!
#if defined(_WIN32) || defined(WIN32)
    #ifndef WIN32_LEAN_AND_MEAN
        #define WIN32_LEAN_AND_MEAN
    #endif
    #ifndef NOMINMAX
        #define NOMINMAX
    #endif
    #include <windows.h>
    #ifdef GetObject
        #undef GetObject
    #endif
    #include <gl/GL.h>
#else
    #include <GL/gl.h>
#endif
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{
 
// Since OpenGL 1.2
#ifndef GL_VERSION_1_2
    #define GL_UNSIGNED_BYTE_2_3_3_REV    0x8362
    #define GL_UNSIGNED_SHORT_5_6_5       0x8363
    #define GL_UNSIGNED_SHORT_5_6_5_REV   0x8364
    #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
    #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
#endif
 
#ifndef GL_UNSIGNED_SHORT_5_5_5_1
    #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
#endif
 
#ifdef TEXTURE_DONT_USE_BGRA_EXT
    #define TEXTURE_FORMAT_24BPP     GL_RGB
    #define TEXTURE_FORMAT_32BPP     GL_RGBA
    #define TEXTURE_FORMAT_16BPP     GL_RGB
    #define TEXTURE_FORMAT_16BPPGREY GL_LUMINANCE
    #define TEXTURE_FORMAT_8BPP      GL_LUMINANCE
#else
    #define TEXTURE_FORMAT_24BPP     GL_BGR_EXT
    #define TEXTURE_FORMAT_32BPP     GL_BGRA_EXT
    #define TEXTURE_FORMAT_16BPP     GL_BGR_EXT
    #define TEXTURE_FORMAT_16BPPGREY GL_LUMINANCE
    #define TEXTURE_FORMAT_8BPP      GL_LUMINANCE
#endif
 
#ifndef GL_BGR
    #define GL_BGR GL_BGR_EXT
#endif
 
#ifndef GL_BGRA
    #define GL_BGRA GL_BGRA_EXT
#endif
 
typedef uint32_t GLenum;
typedef int32_t GLint;

class cGLTexture : public ITexture
{
protected:
    tUInt m_hTexture; 
    tInt m_nPhysicalWidth; 
    tInt m_nPhysicalHeight; 
    tBitmapFormat m_sFormat; 
    ITexture::tTextureMode m_nMode; 
 
public:
    cGLTexture()
    {
        m_hTexture = 0;
        m_nMode = MODE_BilinearFiltered;
 
        adtf::util::cMemoryBlock::MemSet(&m_sFormat, 0, sizeof(m_sFormat));
    }
 
    ~cGLTexture()
    {
        CleanUp();
    }

    tResult Create(const tBitmapFormat* psFormat, tInt nMode = 0)
    {
        CleanUp();
 
        RETURN_IF_POINTER_NULL(psFormat);
 
        if (nMode == 0)
        {
            m_nMode = MODE_NearestPixel;
        }
        else
        {
            m_nMode = (tTextureMode) nMode;
        }
 
        glEnable(GL_TEXTURE_2D);
 
        GLuint l_nTextureId = 0;
        glGenTextures(1, &l_nTextureId);
 
        GLenum l_nStatus = glGetError();
 
        m_hTexture = l_nTextureId;
        m_nPhysicalWidth = cImage::GetNextPowerOfTwo(psFormat->nWidth);
        m_nPhysicalHeight = cImage::GetNextPowerOfTwo(psFormat->nHeight);
 
        adtf::util::cMemoryBlock::MemCopy(&m_sFormat, psFormat, sizeof(m_sFormat));
 
        GLenum nPixelType = GL_UNSIGNED_BYTE;
        GLenum nBitmapFormat = GL_RGB;
        GLint nInternalFormat = GL_RGB;
 
        if (IS_FAILED(CalcOpenGLTextureFormat(&m_sFormat, &nPixelType, &nBitmapFormat, &nInternalFormat)))
        {
            auto bpp = static_cast<int32_t>(m_sFormat.nBitsPerPixel);
            auto fmt = static_cast<int32_t>(m_sFormat.nPixelFormat);
            auto fmtStr = cImage::GetPixelFormatIdentifier(fmt);
            LOG_ERROR("Unsupported pixel format %" PRIi32 " (%s) with %" PRIi32 " bits.", fmt, fmtStr, bpp);
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        cImage oTextureBuffer;
        oTextureBuffer.Create(m_nPhysicalWidth, m_nPhysicalHeight, m_sFormat.nBitsPerPixel, 0, 0,
                              m_sFormat.nPixelFormat);
 
        glBindTexture(GL_TEXTURE_2D, (GLuint) m_hTexture);
 
        l_nStatus = glGetError();
 
        // Use unpack alignment appropiate to image format
        tInt nAlignmentBytes = m_sFormat.nBytesPerLine - m_sFormat.nWidth * m_sFormat.nBitsPerPixel / 8;
        glPixelStorei(GL_UNPACK_ALIGNMENT, (nAlignmentBytes != 0) ? cImage::m_nDefaultLineAlignment : 1);
 
        const void* pBitmap = oTextureBuffer.GetBitmap();
        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
        glTexImage2D(GL_TEXTURE_2D, 0, nInternalFormat, m_nPhysicalWidth, m_nPhysicalHeight, 0, nBitmapFormat,
                     nPixelType, pBitmap);
 
        l_nStatus = glGetError();
        if (l_nStatus != GL_NO_ERROR || m_hTexture == 0)
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
 
        glDisable(GL_TEXTURE_2D);
 
        RETURN_NOERROR;
    }

    tResult CleanUp()
    {
        if (m_hTexture != 0)
        {
            GLuint l_nTextureId = (GLuint) m_hTexture;
            glDeleteTextures(1, &l_nTextureId);
            m_hTexture = 0;
        }
 
        adtf::util::cMemoryBlock::MemSet(&m_sFormat, 0, sizeof(m_sFormat));
 
        RETURN_NOERROR;
    }
 
public:
    tResult Release()
    {
        CleanUp();
 
        delete this;
 
        RETURN_NOERROR;
    }
 
    tVoid MakeCurrent()
    {
        if (m_hTexture == 0)
        {
            return;
        }
 
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, (GLuint) m_hTexture);
 
        if (m_nMode == MODE_BilinearFiltered)
        {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        }
        else
        {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        }
    }
 
    tResult SetMode(tInt nMode)
    {
        m_nMode = (tTextureMode) nMode;
 
        RETURN_NOERROR;
    }
 
    tResult Copy(IImage* pImage)
    {
        RETURN_IF_POINTER_NULL(pImage);
        RETURN_IF_POINTER_NULL(pImage->GetBitmap());
 
        if (m_hTexture == 0)
        {
            RETURN_ERROR(ERR_UNKNOWN);
        }
 
        if (!IsCompatible(pImage->GetFormat()))
        {
            RETURN_IF_FAILED(Create(pImage->GetFormat()));
        }
 
        cImage oImg;
        oImg.Attach(pImage->GetBitmap(), pImage->GetFormat(), pImage->GetPalette());
 
        // Converts any unsupported GPU format to a supported one.
        // Convert before any GPU upload on CPU side.
        // Makes temporary copies due to review remarks.
        if (pImage->GetPixelFormat() == IImage::PF_YUV420P_888)
        {
            // Format not supported by GPU. Convert to RGB.
            oImg = cImage(*pImage);
            oImg.ChangePixelFormat(IImage::PF_RGB_888);
        }
        else if (pImage->GetPixelFormat() == IImage::PF_GREYSCALE_24)
        {
            // Format not supported by GPU. Convert to RGB
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 24, 0, nullptr, IImage::PF_RGB_888);
            constexpr float grey24_to_byte = 255.0f / float((256 * 256 * 256) - 1);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    uint32_t const r = *pSrc++;
                    uint32_t const g = *pSrc++;
                    uint32_t const b = *pSrc++;
                    uint32_t const grey24 = (b << 16) | (g << 8) | r;
                    int32_t const igrey24 = static_cast<int32_t>(static_cast<float>(grey24) * grey24_to_byte);
                    uint8_t const grey8 = static_cast<uint8_t>(std::clamp(igrey24, 0, 255));
                    *pDst++ = grey8;
                    *pDst++ = grey8;
                    *pDst++ = grey8;
                }
            }
        }
        else if (pImage->GetPixelFormat() == IImage::PF_ARGB_8888)
        {
            // Format not supported by GPU. Convert to RGBA.
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 32, 0, nullptr, IImage::PF_RGBA_8888);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    uint8_t const a = *pSrc++;
                    uint8_t const r = *pSrc++;
                    uint8_t const g = *pSrc++;
                    uint8_t const b = *pSrc++;
                    *pDst++ = r;
                    *pDst++ = g;
                    *pDst++ = b;
                    *pDst++ = a;
                }
            }
        }
        else if (pImage->GetPixelFormat() == IImage::PF_ABGR_8888)
        {
            // Format not supported by GPU. Convert to RGBA.
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 32, 0, nullptr, IImage::PF_RGBA_8888);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    uint8_t const a = *pSrc++;
                    uint8_t const b = *pSrc++;
                    uint8_t const g = *pSrc++;
                    uint8_t const r = *pSrc++;
                    *pDst++ = r;
                    *pDst++ = g;
                    *pDst++ = b;
                    *pDst++ = a;
                }
            }
        }
        else if (pImage->GetPixelFormat() == IImage::PF_RGBx_8888)
        {
            // Format RGBA supported by GPU but needs opaque alpha channel.
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 32, 0, nullptr, IImage::PF_RGBA_8888);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    uint8_t const r = *pSrc++;
                    uint8_t const g = *pSrc++;
                    uint8_t const b = *pSrc++;
                    pSrc++;
                    *pDst++ = r;
                    *pDst++ = g;
                    *pDst++ = b;
                    *pDst++ = 255;
                }
            }
        }
        else if (pImage->GetPixelFormat() == IImage::PF_BGRx_8888)
        {
            // Format BGRA supported by GPU but needs opaque alpha channel.
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 32, 0, nullptr, IImage::PF_BGRA_8888);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    uint8_t const b = *pSrc++;
                    uint8_t const g = *pSrc++;
                    uint8_t const r = *pSrc++;
                    pSrc++;
                    *pDst++ = b;
                    *pDst++ = g;
                    *pDst++ = r;
                    *pDst++ = 255;
                }
            }
        }
        else if (pImage->GetPixelFormat() == IImage::PF_xRGB_8888)
        {
            // Format not supported by GPU.
            // Convert to RGBA and make opaque alpha channel in one converter
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 32, 0, nullptr, IImage::PF_RGBA_8888);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    pSrc++;
                    uint8_t const r = *pSrc++;
                    uint8_t const g = *pSrc++;
                    uint8_t const b = *pSrc++;
                    *pDst++ = r;
                    *pDst++ = g;
                    *pDst++ = b;
                    *pDst++ = 255;
                }
            }
        }
        else if (pImage->GetPixelFormat() == cImage::PF_xBGR_8888)
        {
            // Format not supported by GPU.
            // Convert to RGBA and make opaque alpha channel in one converter
            oImg.Create(pImage->GetWidth(), pImage->GetHeight(), 32, 0, nullptr, IImage::PF_RGBA_8888);
 
            for (int y = 0; y < oImg.GetHeight(); ++y)
            {
                uint8_t const* __restrict pSrc = pImage->GetBitmapLine(y);
                uint8_t* __restrict pDst = oImg.GetBitmapLine(y);
 
                for (int x = 0; x < oImg.GetWidth(); ++x)
                {
                    pSrc++;
                    uint8_t const b = *pSrc++;
                    uint8_t const g = *pSrc++;
                    uint8_t const r = *pSrc++;
                    *pDst++ = r;
                    *pDst++ = g;
                    *pDst++ = b;
                    *pDst++ = 255;
                }
            }
        }
 
        GLenum nPixelType = GL_UNSIGNED_BYTE;
        GLenum nBitmapFormat = GL_RGB;
        GLint nInternalFormat = GL_RGB;
 
        RETURN_IF_FAILED(CalcOpenGLTextureFormat(&m_sFormat, &nPixelType, &nBitmapFormat, &nInternalFormat));
 
        glBindTexture(GL_TEXTURE_2D, (GLuint) m_hTexture);
 
        // Use unpack alignment appropriate to image format
        tInt nAlignmentBytes = m_sFormat.nBytesPerLine - m_sFormat.nWidth * m_sFormat.nBitsPerPixel / 8;
        glPixelStorei(GL_UNPACK_ALIGNMENT, (nAlignmentBytes != 0) ? cImage::m_nDefaultLineAlignment : 1);
 
        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 
        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_sFormat.nWidth, m_sFormat.nHeight, nBitmapFormat, nPixelType,
                        oImg.GetBitmap());
 
        GLenum l_nStatus = glGetError();
        if (l_nStatus != GL_NO_ERROR)
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
        RETURN_NOERROR;
    }
 
    tInt GetWidth() const
    {
        return m_sFormat.nWidth;
    }
 
    tInt GetHeight() const
    {
        return m_sFormat.nHeight;
    }
 
    tInt GetBitsPerPixel() const
    {
        return m_sFormat.nBitsPerPixel;
    }
 
    tInt GetPixelFormat() const
    {
        return m_sFormat.nPixelFormat;
    }
 
    tInt GetStride() const
    {
        return m_sFormat.nBytesPerLine;
    }
 
    tInt GetPhysicalWidth() const
    {
        return m_nPhysicalWidth;
    }
 
    tInt GetPhysicalHeight() const
    {
        return m_nPhysicalHeight;
    }
 
public:
    tBool IsCompatible(const tBitmapFormat* psFormat)
    {
        if (m_sFormat.nWidth != psFormat->nWidth || m_sFormat.nHeight != psFormat->nHeight ||
            m_sFormat.nBitsPerPixel != psFormat->nBitsPerPixel || m_sFormat.nPaletteSize != psFormat->nPaletteSize)
        {
            return tFalse;
        }
 
        return tTrue;
    }

    tVoid Blit(tInt x, tInt y, tInt nWidth, tInt nHeight)
    {
        if (m_hTexture == 0)
        {
            return;
        }
 
        MakeCurrent();
 
        tInt x1 = x;
        tInt y1 = y;
        tInt x2 = x + nWidth;
        tInt y2 = y + nHeight;
 
        tFloat64 u = (tFloat64) m_sFormat.nWidth / (tFloat64) m_nPhysicalWidth;
        tFloat64 v = (tFloat64) m_sFormat.nHeight / (tFloat64) m_nPhysicalHeight;
 
        tFloat32 clTemp[4];
        glGetFloatv(GL_CURRENT_COLOR, clTemp);
 
        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 
        glBegin(GL_QUADS);
 
        glTexCoord2d(0, v);
        glVertex2i(x1, y2);
 
        glTexCoord2d(0, 0);
        glVertex2i(x1, y1);
 
        glTexCoord2d(u, 0);
        glVertex2i(x2, y1);
 
        glTexCoord2d(u, v);
        glVertex2i(x2, y2);
 
        glEnd();
 
        glColor4f(clTemp[0], clTemp[1], clTemp[2], clTemp[3]);
 
        glDisable(GL_TEXTURE_2D);
    }

    static tResult CalcOpenGLTextureFormat(const tBitmapFormat* pBitmapInfo,
                                           GLenum* pPixelType,
                                           GLenum* pBitmapFormat,
                                           GLint* pBitmapFormatInternal)
    {
        RETURN_IF_POINTER_NULL_DESC(pBitmapInfo, "No pBitmapInfo.");
 
        GLenum oIntFmt = GL_RGB;
        GLenum oBmpFmt = GL_RGB;
        GLenum oPixFmt = GL_UNSIGNED_BYTE;
 
        int32_t const oPixelFormat = static_cast<int32_t>(pBitmapInfo->nPixelFormat);
 
        // Reference 1:
        // https://afrantzis.com/pixel-format-guide/opengl.html
        // Beware: The paragraph about about 32-bit has errors, see "packed" section.
        // Has 2 nice sentences about RGB_565.
 
        // Reference 2:
        // https://www.mvtec.com/doc/halcon/13/en/gen_image_interleaved.html
        // Beware: Looks nice but who knows actually.
 
        // Benni Defintions:
        //
        // A word like 0bBBBBBGGGGGGRRRRR is little endian
        // meaning byte[0] is 0bGGGRRRRR and byte[1] is 0bBBBBBGGG
        // cImage::Convert() seems to swap byte0 and byte1 for 16-bit formats!
        // This still needs investigation. But i take a correct render as reference now.
 
        switch (oPixelFormat)
        {
                // 32-Bit:
            case IImage::PF_GREYSCALE_32:
            {
                oIntFmt = GL_LUMINANCE;
                oBmpFmt = GL_LUMINANCE;
                oPixFmt = GL_UNSIGNED_INT;
                break;
            } // Supported by GPU.
            case IImage::PF_32BIT:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // Interpreted as RGBA_8888
            case IImage::PF_RGBA_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // = 0xAABBGGRR. Supported by GPU
            case IImage::PF_BGRA_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_BGRA;
                break;
            } // = 0xAARRGGBB. Supported by GPU
            case IImage::PF_ARGB_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // = 0xBBGGRRAA. Converted to RGBA_8888.
            case IImage::PF_ABGR_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // = 0xRRGGBBAA. Converted to RGBA_8888.
            case IImage::PF_RGBx_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // = 0xFFBBGGRR. Copied and alpha set to 255 (opaque)
            case IImage::PF_BGRx_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_BGRA;
                break;
            } // = 0xFFRRGGBB. Copied and alpha set to 255 (opaque)
            case IImage::PF_xRGB_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // = 0xBBGGRRFF. Converted to RGBA_8888 and alpha set to 255 (opaque)
            case IImage::PF_xBGR_8888:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                break;
            } // = 0xRRGGBBAA. Converted to RGBA_8888 and alpha set to 255 (opaque)
              // 24-Bit:
            case IImage::PF_GREYSCALE_24:
            {
                oIntFmt = GL_LUMINANCE;
                oBmpFmt = GL_LUMINANCE;
                break;
            } // Supported by GPU.
            case IImage::PF_24BIT:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_RGB;
                break;
            } // Interpreted as RGB_888
            case IImage::PF_RGB_888:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_RGB;
                break;
            } // = 0xAABBGGRR. Supported by GPU
            case IImage::PF_BGR_888:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_BGR;
                break;
            } // = 0xAARRGGBB. Supported by GPU
            case IImage::PF_YUV420P_888:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_RGB;
                break;
            } // Converted to RGB_888
              // 16-Bit:
            case IImage::PF_GREYSCALE_16:
            {
                oIntFmt = GL_LUMINANCE;
                oBmpFmt = GL_LUMINANCE;
                oPixFmt = GL_UNSIGNED_SHORT;
                break;
            } // Supported by GPU.
            case IImage::PF_16BIT:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_RGB;
                oPixFmt = GL_UNSIGNED_SHORT_5_6_5_REV;
                break;
            } // Interpreted as RGB_565
            case IImage::PF_RGB_565:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_RGB;
                oPixFmt = GL_UNSIGNED_SHORT_5_6_5_REV;
                break;
            } // = 0bBBBBBGGGGGGRRRRR. Supported by GPU. Still need to check img.Convert()!
            case IImage::PF_BGR_565:
            {
                oIntFmt = GL_RGB;
                oBmpFmt = GL_RGB;
                oPixFmt = GL_UNSIGNED_SHORT_5_6_5;
                break;
            } // = 0bRRRRRGGGGGGBBBBB. Supported by GPU. GL_BGR not working! Still need to check img.Convert()!
            case IImage::PF_RGB_555:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                oPixFmt = GL_UNSIGNED_SHORT_1_5_5_5_REV;
                break;
            } // = 0b1BBBBBGGGGGRRRRR. Supported by GPU.
            case IImage::PF_BGR_555:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_BGRA;
                oPixFmt = GL_UNSIGNED_SHORT_1_5_5_5_REV;
                break;
            } // = 0b1RRRRRGGGGGBBBBB. Supported by GPU.
            case IImage::PF_RGBA_5551:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                oPixFmt = GL_UNSIGNED_SHORT_1_5_5_5_REV;
                break;
            } // = 0bABBBBBGGGGGRRRRR. Supported by GPU.
            case IImage::PF_BGRA_5551:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_BGRA;
                oPixFmt = GL_UNSIGNED_SHORT_1_5_5_5_REV;
                break;
            } // = 0bARRRRRGGGGGBBBBB. Supported by GPU.
            case IImage::PF_ARGB_1555:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_BGRA;
                oPixFmt = GL_UNSIGNED_SHORT_5_5_5_1;
                break;
            } // = 0bBBBBBGGGGGRRRRRA. Supported by GPU.
            case IImage::PF_ABGR_1555:
            {
                oIntFmt = GL_RGBA;
                oBmpFmt = GL_RGBA;
                oPixFmt = GL_UNSIGNED_SHORT_5_5_5_1;
                break;
            } // = 0bRRRRRGGGGGBBBBBA. Supported by GPU.
              // 8-Bit:
            case IImage::PF_GREYSCALE_8:
            {
                oIntFmt = GL_LUMINANCE;
                oBmpFmt = GL_LUMINANCE;
                break;
            } // Supported by GPU.
            case IImage::PF_8BIT:
            {
                oIntFmt = GL_LUMINANCE;
                oBmpFmt = GL_LUMINANCE;
                break;
            } // Interpreted as GREYSCALE_8.
              // Unsupported:
            default:
            {
                RETURN_ERROR_DESC(ERR_NOT_SUPPORTED, "No support for PixelFormat %d", int(oPixelFormat));
            }
        }
 
        *pPixelType = oPixFmt;
        *pBitmapFormat = oBmpFmt;
        *pBitmapFormatInternal = oIntFmt;
        RETURN_NOERROR;
    }

    explicit operator ITexture*()
    {
        return static_cast<ITexture*>(this);
    }
};
 
} // namespace dengar
 
using dengar::cGLTexture;
 
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf