glcanvas.h

Go to the documentation of this file.

#pragma once
 
#ifndef PI
    #define PI 3.1415926535897932384626433832795
#endif
 
#include <adtf_base.h>
 
#ifdef WIN32
    #include <windows.h>
    #include <gl/GLU.h>
    #include <gl/GL.h>
#else
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <fontconfig/fontconfig.h>
#endif
 
#ifdef GetObject
    #undef GetObject
#endif
 
#include <adtfdisplaytoolboxgraphics/gfxlibinterfaces.h>
#include <adtfdisplaytoolboxgraphics/image.h>
#include <adtfdisplaytoolboxgraphics/glfont.h>
#include <adtfdisplaytoolboxgraphics/gltexture.h>
#include <adtfdisplaytoolboxgraphics/rect_intf.h>
 
#include <cmath>
 
#ifndef GL_BGR
    // #define GL_BGR GL_BGR_EXT
    #define GL_BGR GL_BGRA_EXT
#endif
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{

 
class cGLCanvas : public ucom::catwo::object<ICanvas>
{
    friend class cGLFont;
 
protected:
    struct sFlags
    {
        tBool bTextOppsedYAxis; 
        tBool bTextScales; 
        tBool bTextRotate; 
        tBool bTextBaselineOnTop;
    };
 
protected:
    IFont* m_pCurrentFont;
    tBool m_bUseMapping;
    tFloat64 m_fFontAngle;
    GLUquadricObj* m_pGLUQuadric;
    tUInt32 m_nMode;
    tInt m_nBitsPerPixel;
    tInt m_nHeight;
    tInt m_nWidth;
    tFloat32 m_f32MappingX1;
    tFloat32 m_f32MappingY1;
    tFloat32 m_f32MappingX2;
    tFloat32 m_f32MappingY2;
    tFloat32 m_f32MappingWidth;
    tFloat32 m_f32MappingHeight;
    std::stack<sFlags> m_oFlags;
    sFlags m_oCurrentFlags;
    cImage m_oCaptureBuffer;
 
public:
    cGLCanvas():
        m_pCurrentFont(nullptr),
        m_bUseMapping(tFalse),
        m_fFontAngle(0.0),
        m_pGLUQuadric(nullptr),
        m_nMode(COORDS_SCREEN)
    {
        ResetFlags();
    }

    virtual ~cGLCanvas() final
    {
        Release();
    }

    tResult Create(tInt nWidth, tInt nHeight, tInt nBitsPerPixel) override
    {
        m_bUseMapping = tFalse;
 
        glShadeModel(GL_SMOOTH);
        glDisable(GL_LIGHTING);
        glDisable(GL_ALPHA_TEST);
        glDisable(GL_BLEND);
        glDisable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
        glCullFace(GL_BACK);
        glClearDepth(1.0f);
        glDepthFunc(GL_LESS);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        BgColor(0.0, 0.0, 0.0, 0.0);
 
        m_nWidth = nWidth;
        m_nHeight = nHeight;
        m_nBitsPerPixel = nBitsPerPixel;
        m_pGLUQuadric = gluNewQuadric();
 
        SwitchToScreenCoords();
 
        glDepthMask(GL_TRUE);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_CULL_FACE);
        glDisable(GL_LIGHTING);
 
        m_nMode = COORDS_SCREEN;
 
        RETURN_NOERROR;
    }

    tResult Resize(tInt nWidth, tInt nHeight)
    {
        m_nWidth = nWidth;
        m_nHeight = nHeight;
        SwitchToScreenCoords();
 
        RETURN_NOERROR;
    }

    tResult Release()
    {
        if (m_pGLUQuadric != NULL)
        {
            gluDeleteQuadric(m_pGLUQuadric);
            m_pGLUQuadric = NULL;
        }
 
        m_pCurrentFont = NULL;
 
        m_oCaptureBuffer.Release();
        RETURN_NOERROR;
    }

    tUInt32 GetMode()
    {
        if (m_bUseMapping)
        {
            return COORDS_LOGICAL;
        }
 
        return m_nMode;
    }
 
    template<typename T>
    static tVoid Sort(T& a, T& b)
    {
        T vTmp;
 
        if (a > b)
        {
            vTmp = a;
            a = b;
            b = vTmp;
        }
    }

    tVoid NormalizeRect(tInt& x1, tInt& y1, tInt& x2, tInt& y2) const
    {
        Sort<tInt>(x1, x2);
        Sort<tInt>(y1, y2);
    }

    tVoid NormalizeRect(tFloat32& x1, tFloat32& y1, tFloat32& x2, tFloat32& y2) const
    {
        Sort<tFloat32>(x1, x2);
        Sort<tFloat32>(y1, y2);
    }

 
    tVoid Coord(tFloat32* pXCoords, tFloat32* pYCoords, tInt nCount)
    {
        for (tInt l_nIdx = 0; l_nIdx < nCount; l_nIdx++)
        {
            glVertex2f(*(pXCoords++), *(pYCoords++));
        }
    }
 
    virtual tVoid FlipTextHorizontally(tBool bOpposedYAxis)
    {
        m_oCurrentFlags.bTextOppsedYAxis = bOpposedYAxis;
    };
 
    virtual tVoid TextScaleWithZoom(tBool bScaleWithZoom)
    {
        m_oCurrentFlags.bTextScales = bScaleWithZoom;
    }
 
public: // implements IGraphicsMode
    tBool IsSupported(tFeature nFeatureId) const override
    {
        if (nFeatureId == FEATURE_AlphaBlending || nFeatureId == FEATURE_Antialiasing ||
            nFeatureId == FEATURE_Lighting || nFeatureId == FEATURE_DepthBuffer ||
            nFeatureId == FEATURE_BackFaceCulling || nFeatureId == FEATURE_CommandLists ||
            nFeatureId == FEATURE_HardwareAcceleration)
        {
            return tTrue;
        }
 
        return tFalse;
    }
 
    tVoid EnableAlpha(tBool bAdditiveMode = tFalse) const override
    {
        glEnable(GL_BLEND);
        if (bAdditiveMode)
        {
            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
        }
        else
        {
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
        glDisable(GL_ALPHA_TEST);
    }
 
    tVoid DisableAlpha() const override
    {
        glDisable(GL_BLEND);
    }
 
    tVoid EnableAntialiasing() const override
    {
        glEnable(GL_LINE_SMOOTH);
        glEnable(GL_POINT_SMOOTH);
        glEnable(GL_POLYGON_SMOOTH);
    }
 
    tVoid DisableAntialiasing() const override
    {
        glDisable(GL_LINE_SMOOTH);
        glDisable(GL_POINT_SMOOTH);
        glDisable(GL_POLYGON_SMOOTH);
    }
 
    tVoid EnableLighting() const override
    {
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
 
        glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0f);
 
        GLfloat ambient_light[4];
        ambient_light[0] = 0.2f;
        ambient_light[1] = 0.2f;
        ambient_light[2] = 0.2f;
        ambient_light[3] = 0.2f;
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient_light);
 
        GLfloat diffuse_light[4];
        diffuse_light[0] = 0.8f;
        diffuse_light[1] = 0.8f;
        diffuse_light[2] = 0.8f;
        diffuse_light[3] = 0.8f;
        glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse_light);
 
        GLfloat specular_light[4];
        specular_light[0] = 1.0f;
        specular_light[1] = 1.0f;
        specular_light[2] = 1.0f;
        specular_light[3] = 1.0f;
        glLightfv(GL_LIGHT0, GL_SPECULAR, specular_light);
 
        glEnable(GL_COLOR_MATERIAL);
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
 
        GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
        GLfloat mat_shininess[] = {80.0};
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
 
        glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 180.0);
        glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.0);
 
        glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0f);
        glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.0f);
        glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.0f);
    }
 
    tVoid DisableLighting() const override
    {
        glDisable(GL_LIGHTING);
        glDisable(GL_LIGHT0);
        glDisable(GL_COLOR_MATERIAL);
    }
 
    tVoid EnableDepthBuffer() const override
    {
        glEnable(GL_DEPTH_TEST);
        glDepthMask(GL_TRUE);
    }
 
    tVoid DisableDepthBuffer() const override
    {
        glDisable(GL_DEPTH_TEST);
        glDepthMask(GL_FALSE);
    }
 
    tVoid EnableBackFaceCulling() const override
    {
        glEnable(GL_CULL_FACE);
    }
 
    tVoid DisableBackFaceCulling() const override
    {
        glDisable(GL_CULL_FACE);
    }
 
    tVoid LineWidth(tFloat64 fWidth) override
    {
        glLineWidth((GLfloat) fWidth);
        glPointSize((GLfloat) fWidth);
    }
 
    tVoid LinePattern(tUInt16 ui16Pattern, tInt nFactor = 1) override
    {
        if (ui16Pattern != 0xFFFF)
        {
            glEnable(GL_LINE_STIPPLE);
        }
        else
        {
            glDisable(GL_LINE_STIPPLE);
        }
 
        glLineStipple(nFactor, ui16Pattern);
    }
 
    tVoid Color(const IColor* col) override
    {
        glColor4ub(col->GetRed(), col->GetGreen(), col->GetBlue(), col->GetAlpha());
    }
 
    tVoid Color(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 255) override
    {
        glColor4ub((tUInt8) nRed, (tUInt8) nGreen, (tUInt8) nBlue, (tUInt8) nAlpha);
    }
 
    tVoid Color(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255) override
    {
        glColor4ub(nRed, nGreen, nBlue, nAlpha);
    }
 
    tVoid Color(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 1.0) override
    {
        glColor4d(fRed, fGreen, fBlue, fAlpha);
    }
 
    tVoid BgColor(const IColor* col) override
    {
        BgColor(col->GetRed() / 255.0, col->GetGreen() / 255.0, col->GetBlue() / 255.0, col->GetAlpha() / 255.0);
    }
 
    tVoid BgColor(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 255) override
    {
        BgColor(nRed / 255.0, nGreen / 255.0, nBlue / 255.0, nAlpha / 255.0);
    }
 
    tVoid BgColor(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255) override
    {
        BgColor(nRed / 255.0, nGreen / 255.0, nBlue / 255.0, nAlpha / 255.0);
    }
 
    tVoid BgColor(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 0.0) override
    {
        glClearColor((GLclampf) fRed, (GLclampf) fGreen, (GLclampf) fBlue, (GLclampf) fAlpha);
    }
 
    tVoid Begin(tMode eMode) override
    {
        GLenum l_eGLMode = 0;
 
        switch (eMode)
        {
            case MODE_DrawPoints:
            {
                l_eGLMode = GL_POINTS;
                break;
            }
            case MODE_DrawLines:
            {
                l_eGLMode = GL_LINES;
                break;
            }
            case MODE_DrawLineStrip:
            {
                l_eGLMode = GL_LINE_STRIP;
                break;
            }
            case MODE_DrawLineLoop:
            {
                l_eGLMode = GL_LINE_LOOP;
                break;
            }
            case MODE_DrawTriangles:
            {
                l_eGLMode = GL_TRIANGLES;
                break;
            }
            case MODE_DrawTriangleStrip:
            {
                l_eGLMode = GL_TRIANGLE_STRIP;
                break;
            }
            case MODE_DrawTriangleFan:
            {
                l_eGLMode = GL_TRIANGLE_FAN;
                break;
            }
            case MODE_DrawQuads:
            {
                l_eGLMode = GL_QUADS;
                break;
            }
            case MODE_DrawQuadStrip:
            {
                l_eGLMode = GL_QUAD_STRIP;
                break;
            }
            case MODE_DrawPolygon:
            {
                l_eGLMode = GL_POLYGON;
                break;
            }
            default:
            {
                return;
            }
        }
 
        glBegin(l_eGLMode);
    }
 
    tVoid Coord(tInt x, tInt y) override
    {
        glVertex2i(x, y);
    }
 
    tVoid Coord(tFloat32 x, tFloat32 y) override
    {
        glVertex2f(x, y);
    }
 
    tVoid Coord(IPoint* pt) override
    {
        glVertex2i(pt->GetX(), pt->GetY());
    }
 
    tVoid Coord(IPoint** ppPoints, tInt nCount) override
    {
        for (tInt l_nIdx = 0; l_nIdx < nCount; l_nIdx++)
        {
            glVertex2i(ppPoints[l_nIdx]->GetX(), ppPoints[l_nIdx]->GetY());
        }
    }
 
    tVoid CoordTexture(tFloat32 u, tFloat32 v) override
    {
        glTexCoord2f(u, v);
    }
 
    tVoid End() override
    {
        glEnd();
    }
 
public: // implements ICanvas
    tInt GetWidth() const override
    {
        return m_nWidth;
    }
 
    tInt GetHeight() const override
    {
        return m_nHeight;
    }
 
    tInt GetBitsPerPixel() const override
    {
        return m_nBitsPerPixel;
    }
 
    tVoid SetMapping(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override
    {
        m_f32MappingX1 = x1;
        m_f32MappingY1 = y1;
        m_f32MappingX2 = x2;
        m_f32MappingY2 = y2;
        m_f32MappingWidth = x2 - x1;
        m_f32MappingHeight = y2 - y1;
        m_bUseMapping = tTrue;
 
        SwitchToScreenCoords();
    }
 
    tVoid ClearMapping() override
    {
        m_bUseMapping = tFalse;
        SwitchToScreenCoords();
    }
 
    tInt MapPixelX(tFloat32 x) override
    {
        if (m_bUseMapping)
        {
            return (tInt) ((x - m_f32MappingX1) * (tFloat32) m_nWidth / m_f32MappingWidth);
        }
 
        return (tInt) x;
    }
 
    tInt MapPixelY(tFloat32 y) override
    {
        if (m_bUseMapping)
        {
            return (tInt) ((y - m_f32MappingY1) * (tFloat32) m_nHeight / m_f32MappingHeight);
        }
 
        return (tInt) y;
    }
 
    tInt MapPixelX(tInt x) override
    {
        if (m_bUseMapping)
        {
            return (tInt) (((tFloat32) x - m_f32MappingX1) * (tFloat32) m_nWidth / m_f32MappingWidth);
        }
 
        return (tInt) x;
    }
 
    tInt MapPixelY(tInt y) override
    {
        if (m_bUseMapping)
        {
            return (tInt) (((tFloat32) y - m_f32MappingY1) * (tFloat32) m_nHeight / m_f32MappingHeight);
        }
 
        return (tInt) y;
    }
 
    tFloat32 UnmapPixelX(tInt x) override
    {
        if (m_bUseMapping)
        {
            return m_f32MappingX1 + ((tFloat32) x * m_f32MappingWidth) / (tFloat32) m_nWidth;
        }
 
        return (tFloat32) x;
    }
 
    tFloat32 UnmapPixelY(tInt y) override
    {
        if (m_bUseMapping)
        {
            return m_f32MappingY1 + ((tFloat32) y * m_f32MappingHeight) / (tFloat32) m_nHeight;
        }
 
        return (tFloat32) y;
    }
 
    tVoid Clear() override
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }
 
    tResult CreateTexture(IImage* pImage, ITexture*& pTexture) override
    {
        RETURN_IF_POINTER_NULL(pImage);
 
        if (pTexture != nullptr)
        {
            pTexture->Release();
            pTexture = nullptr;
        }
 
        pTexture = CreateTexture(pImage->GetFormat(), ITexture::MODE_BilinearFiltered);
        RETURN_IF_POINTER_NULL(pTexture);
        pTexture->Copy(pImage);
        RETURN_NOERROR;
    }
 
    tVoid DrawTexture(ITexture* pTexture, tFloat32 vPoints[8]) override
    {
        if (!pTexture)
        {
            return; // Nothing todo.
        }
        Color(255, 255, 255);
 
        pTexture->MakeCurrent();
 
        tFloat32 u = (tFloat32) pTexture->GetWidth() / pTexture->GetPhysicalWidth();
        tFloat32 v = (tFloat32) pTexture->GetHeight() / pTexture->GetPhysicalHeight();
 
        glBegin(GL_QUADS);
        glTexCoord2d(u, v);
        glVertex2f(vPoints[0], vPoints[1]);
 
        glTexCoord2d(u, 0);
        glVertex2f(vPoints[2], vPoints[3]);
 
        glTexCoord2d(0, 0);
        glVertex2f(vPoints[4], vPoints[5]);
 
        glTexCoord2d(0, v);
        glVertex2f(vPoints[6], vPoints[7]);
        glEnd();
 
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_BLEND);
    }
 
    tVoid DrawPixel(tInt x, tInt y) override
    {
        glBegin(GL_POINTS);
        Coord(x, y);
        glEnd();
    }
 
    tVoid DrawPixel(tFloat32 x, tFloat32 y) override
    {
        glBegin(GL_POINTS);
        Coord(x, y);
        glEnd();
    }
 
    tVoid DrawPixel(IPoint* pt) override
    {
        DrawPixel(pt->GetX(), pt->GetY());
    }
 
    tVoid DrawLine(tInt x1, tInt y1, tInt x2, tInt y2) override
    {
        glBegin(GL_LINES);
        CoordLine(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid DrawLine(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override
    {
        glBegin(GL_LINES);
        CoordLine(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid DrawLine(IPoint* ptStart, IPoint* ptEnd) override
    {
        DrawLine(ptStart->GetX(), ptStart->GetY(), ptEnd->GetX(), ptEnd->GetY());
    }
 
    tVoid DrawRect(tInt x1, tInt y1, tInt x2, tInt y2) override
    {
        glBegin(GL_LINE_LOOP);
        CoordRect(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid DrawRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override
    {
        glBegin(GL_LINE_LOOP);
        CoordRect(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid DrawRect(IRect* rect) override
    {
        DrawRect(rect->GetLeft(), rect->GetTop(), rect->GetRight(), rect->GetBottom());
    }
 
    tVoid DrawCircle(tInt x1, tInt y1, tInt x2, tInt y2) override
    {
        glBegin(GL_LINE_LOOP);
        CoordCircle(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid DrawCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override
    {
        glBegin(GL_LINE_LOOP);
        CoordCircle(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid DrawCircle(IRect* rect) override
    {
        glBegin(GL_LINE_LOOP);
        CoordCircle(rect->GetLeft(), rect->GetTop(), rect->GetRight(), rect->GetBottom());
        glEnd();
    }
 
    tVoid DrawCircleSegment(tInt x1,
                            tInt y1,
                            tInt x2,
                            tInt y2,
                            tFloat64 fDegreeStart,
                            tFloat64 fDegreeEnd,
                            tBool bNormalizeRect = tFalse) override
    {
        if (bNormalizeRect)
        {
            NormalizeRect(x1, y1, x2, y2);
        }
 
        glBegin(GL_LINE_LOOP);
        Coord((x1 + x2) / 2, (y1 + y2) / 2);
        CoordCircleSegment(x1, y1, x2, y2, fDegreeStart, fDegreeEnd);
        glEnd();
    }
 
    tVoid DrawCircleSegment(tFloat32 x1,
                            tFloat32 y1,
                            tFloat32 x2,
                            tFloat32 y2,
                            tFloat64 fDegreeStart,
                            tFloat64 fDegreeEnd,
                            tBool bNormalizeRect = tFalse) override
    {
        if (bNormalizeRect)
        {
            NormalizeRect(x1, y1, x2, y2);
        }
 
        glBegin(GL_LINE_LOOP);
        Coord((x1 + x2) / 2.0f, (y1 + y2) / 2.0f);
        CoordCircleSegment(x1, y1, x2, y2, fDegreeStart, fDegreeEnd);
        glEnd();
    }
 
    tVoid DrawCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) override
    {
        DrawCircleSegment(rect->GetLeft(), rect->GetTop(), rect->GetRight(), rect->GetBottom(), fDegreeStart,
                          fDegreeEnd);
    }
 
    tVoid DrawPolygon(IPoint** ppPoints, tInt nCount) override
    {
        glBegin(GL_LINE_LOOP);
        Coord(ppPoints, nCount);
        glEnd();
    }
 
    tVoid FillRect(tInt x1, tInt y1, tInt x2, tInt y2) override
    {
        glBegin(GL_QUADS);
        glNormal3f(0.0, 0.0, -1.0f);
        CoordRect(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid FillRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override
    {
        glBegin(GL_QUADS);
        glNormal3f(0.0, 0.0, -1.0f);
        CoordRect(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid FillRect(IRect* rect) override
    {
        FillRect(rect->GetLeft(), rect->GetTop(), rect->GetRight(), rect->GetBottom());
    }
 
    tVoid FillCircle(tInt x1, tInt y1, tInt x2, tInt y2) override
    {
        glBegin(GL_TRIANGLE_FAN);
        glNormal3f(0.0f, 0.0f, -1.0f);
        glVertex2i((x1 + x2) / 2, (y1 + y2) / 2);
        CoordCircle(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid FillCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override
    {
        glBegin(GL_TRIANGLE_FAN);
        glNormal3f(0.0f, 0.0f, -1.0f);
        glVertex2f((x1 + x2) / 2, (y1 + y2) / 2);
        CoordCircle(x1, y1, x2, y2);
        glEnd();
    }
 
    tVoid FillCircle(IRect* rect) override
    {
        return FillCircle(rect->GetLeft(), rect->GetTop(), rect->GetRight(), rect->GetBottom());
    }
 
    tVoid FillCircleSegment(tInt x1,
                            tInt y1,
                            tInt x2,
                            tInt y2,
                            tFloat64 fDegreeStart,
                            tFloat64 fDegreeEnd,
                            tBool bNormalizeRect = tFalse) override
    {
        if (bNormalizeRect)
        {
            NormalizeRect(x1, y1, x2, y2);
        }
 
        glBegin(GL_TRIANGLE_FAN);
        glNormal3f(0.0, 0.0, -1.0f);
        glVertex2i((x1 + x2) / 2, (y1 + y2) / 2);
        CoordCircleSegment(x1, y1, x2, y2, fDegreeStart, fDegreeEnd);
        glEnd();
    }
 
    tVoid FillCircleSegment(tFloat32 x1,
                            tFloat32 y1,
                            tFloat32 x2,
                            tFloat32 y2,
                            tFloat64 fDegreeStart,
                            tFloat64 fDegreeEnd,
                            tBool bNormalizeRect = tFalse) override
    {
        if (bNormalizeRect)
        {
            NormalizeRect(x1, y1, x2, y2);
        }
 
        glBegin(GL_TRIANGLE_FAN);
        glNormal3f(0.0f, 0.0f, -1.0f);
        glVertex2f((x1 + x2) / 2.0f, (y1 + y2) / 2.0f);
        CoordCircleSegment(x1, y1, x2, y2, fDegreeStart, fDegreeEnd);
        glEnd();
    }
 
    tVoid FillCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) override
    {
        return FillCircleSegment(rect->GetLeft(), rect->GetTop(), rect->GetRight(), rect->GetBottom(), fDegreeStart,
                                 fDegreeEnd);
    }
 
    tVoid FillPolygon(IPoint** ppPoints, tInt nCount) override
    {
        glBegin(GL_POLYGON);
        glNormal3f(0.0, 0.0, -1.0f);
        Coord(ppPoints, nCount);
        glEnd();
    }
 
    IFont* CreateFont(const char* strName, tInt nHeight, IFont::tStyle eFontStyle = IFont::STYLE_Default)
    {
        cGLFont* l_pFont = new cGLFont();
        if (l_pFont == NULL)
        {
            return NULL;
        }
 
        if (IS_FAILED(l_pFont->Create(this, strName, nHeight, eFontStyle)))
        {
            delete l_pFont;
            return NULL;
        }
 
        return static_cast<IFont*>(l_pFont);
    }
 
    tVoid SetFontAngle(tFloat64 fAngle)
    {
        m_fFontAngle = fAngle;
    }
 
    tFloat64 GetFontAngle()
    {
        return m_fFontAngle;
    }
 
    tVoid Font(IFont* pFont)
    {
        m_pCurrentFont = pFont;
    }
 
    tVoid OutputText(tInt x, tInt y, const char* strFormat, ...)
    {
        if (m_pCurrentFont == NULL)
        {
            return;
        }
 
        ((cGLFont*) m_pCurrentFont)->FlipTextHorizontally(m_oCurrentFlags.bTextOppsedYAxis);
        ((cGLFont*) m_pCurrentFont)->TextScaleWithCoordinateSystem(m_oCurrentFlags.bTextScales);
        ((cGLFont*) m_pCurrentFont)->TextRotateWithCoordinateSystem(m_oCurrentFlags.bTextRotate);
        ((cGLFont*) m_pCurrentFont)->TextBaselineOnTop(m_oCurrentFlags.bTextBaselineOnTop);
 
        va_list ap;
        va_start(ap, strFormat);
 
        if (m_bUseMapping)
        {
            tInt x_mapped = MapPixelX(x);
            tInt y_mapped = MapPixelY(y);
 
            // m_bUseMapping = tFalse;     // disable mapping to atVoid stretching the text
            // SwitchToScreenCoords();
 
            ClearMapping();
 
            ((cGLFont*) m_pCurrentFont)->Print(x_mapped, y_mapped, m_fFontAngle, strFormat, ap);
 
            SetMapping(m_f32MappingX1, m_f32MappingY1, m_f32MappingX2, m_f32MappingY2);
        }
        else
        {
            ((cGLFont*) m_pCurrentFont)->Print(x, y, m_fFontAngle, strFormat, ap);
        }
 
        va_end(ap);
    }
 
    tVoid OutputText(tFloat32 x, tFloat32 y, const char* strFormat, ...)
    {
        if (m_pCurrentFont == NULL)
        {
            return;
        }
 
        ((cGLFont*) m_pCurrentFont)->FlipTextHorizontally(m_oCurrentFlags.bTextOppsedYAxis);
        ((cGLFont*) m_pCurrentFont)->TextScaleWithCoordinateSystem(m_oCurrentFlags.bTextScales);
        ((cGLFont*) m_pCurrentFont)->TextRotateWithCoordinateSystem(m_oCurrentFlags.bTextRotate);
        ((cGLFont*) m_pCurrentFont)->TextBaselineOnTop(m_oCurrentFlags.bTextBaselineOnTop);
 
        va_list ap;
        va_start(ap, strFormat);
 
        if (m_bUseMapping)
        {
            tInt x_mapped = MapPixelX(x);
            tInt y_mapped = MapPixelY(y);
 
            // m_bUseMapping = tFalse;     // disable mapping to atVoid stretching the text
            // SwitchToScreenCoords();
            ClearMapping();
 
            ((cGLFont*) m_pCurrentFont)->Print(x_mapped, y_mapped, m_fFontAngle, strFormat, ap);
 
            /*m_bUseMapping = tTrue;
            SwitchToScreenCoords();*/
            SetMapping(m_f32MappingX1, m_f32MappingY1, m_f32MappingX2, m_f32MappingY2);
        }
        else
        {
            ((cGLFont*) m_pCurrentFont)->Print(x, y, m_fFontAngle, strFormat, ap);
        }
 
        va_end(ap);
    }
 
    ITexture* CreateTexture(const tBitmapFormat* psFormat, tInt nMode = 0) override
    {
        cGLTexture* l_pTexture = new cGLTexture();
        if (l_pTexture == NULL)
        {
            return NULL;
        }
 
        if (IS_FAILED(l_pTexture->Create(psFormat, nMode)))
        {
            delete l_pTexture;
            return NULL;
        }
 
        return static_cast<ITexture*>(l_pTexture);
    }
 
    tVoid Texture(ITexture* pTexture) override
    {
        if (pTexture == NULL)
        {
            // just turn off texturing
            glDisable(GL_TEXTURE_2D);
            return;
        }
 
        ((cGLTexture*) pTexture)->MakeCurrent();
    }
 
    tVoid Blit(ITexture* pTexture, tInt x, tInt y, tInt nWidth, tInt nHeight) override
    {
        if (pTexture == NULL)
        {
            return;
        }
 
        ((cGLTexture*) pTexture)->Blit(x, y, nWidth, nHeight);
    }
 
    tVoid Blit(IImage* pImage, tInt x, tInt y, tInt nWidth, tInt nHeight) override
    {
        if (pImage == NULL)
        {
            return;
        }
 
        tVoid* pBitmap = pImage->GetBitmap();
        if (pBitmap == NULL)
        {
            return;
        }
 
        tBool bBGR = tFalse;
 
        switch (pImage->GetPixelFormat())
        {
            case cImage::PF_RGB_888:
            case cImage::PF_RGBA_8888:
            {
                bBGR = tTrue;
            }
            break;
 
            case cImage::PF_BGR_888:
            case cImage::PF_BGRA_8888:
            {
                bBGR = tFalse;
            }
            break;
 
            default:
            {
                cImage oImage;
                tBitmapFormat sFormat = *(pImage->GetFormat());
                sFormat.nBytesPerLine = 0;
                sFormat.nSize = 0;
 
                oImage.Create(sFormat.nWidth, sFormat.nHeight, sFormat.nBitsPerPixel, sFormat.nBytesPerLine,
                              pImage->GetBitmap(), sFormat.nPixelFormat);
 
                switch (pImage->GetBitsPerPixel())
                {
                    case 32:
                    {
                        sFormat.nPixelFormat = cImage::PF_RGBA_8888;
                        sFormat.nBitsPerPixel = 32;
                    }
                    break;
 
                    case 24:
                    default:
                    {
                        sFormat.nPixelFormat = cImage::PF_RGB_888;
                        sFormat.nBitsPerPixel = 24;
                    }
                    break;
                }
 
                if (IS_FAILED(oImage.Convert(&sFormat)))
                {
                    LOG_ERROR("Cannot convert image!");
                    return;
                }
                Blit(&oImage, x, y, nWidth, nHeight);
            }
                return;
        }
 
        GLenum l_nFormat = 0;
 
        switch (pImage->GetBitsPerPixel())
        {
            case 32:
            {
                l_nFormat = (bBGR ? GL_BGRA_EXT : GL_RGBA);
                break;
            }
            case 24:
            {
                l_nFormat = (bBGR ? GL_BGR_EXT : GL_RGB);
                break;
            }
            case 8:
            {
                l_nFormat = GL_LUMINANCE;
                break;
            }
            default:
            {
                return;
            }
        }
 
        glPixelStorei(GL_PACK_ROW_LENGTH, pImage->GetWidth());
        glPixelStorei(GL_PACK_ALIGNMENT, 4);
 
        // check whether clipping is needed or not
        if ((x >= 0) && (y >= 0) && ((x + nWidth) <= GetWidth()) && ((y + nHeight) <= GetHeight()))
        {
            // completely inside => no clipping needed
            glRasterPos2i(x, y);
            glPixelZoom((float) (nWidth) / pImage->GetWidth(), -(float) (nHeight) / pImage->GetHeight());
            glDrawPixels(pImage->GetWidth(), pImage->GetHeight(), l_nFormat, GL_UNSIGNED_BYTE, pBitmap);
            glPixelZoom(1.0f, 1.0f);
        }
        else
        {
            if ((x >= GetWidth()) || (y >= GetHeight()) || (x + nWidth < 0) || (y + nHeight < 0))
            {
                // src rect is completely outside => nothing to do
                return;
            }
            else
            {
                tInt x1 = (x < 0) ? 0 : x;
                tInt y1 = (y < 0) ? 0 : y;
                tInt x2 = (x < 0) ? nWidth + x : nWidth;
                tInt y2 = (y < 0) ? nHeight + y : nHeight;
 
                tInt xs = (x < 0) ? -x : 0;
                tInt ys = (y < 0) ? -y : 0;
 
                glPixelZoom(1.0, -1.0);
                tUInt8* pData = (tUInt8*) pBitmap + xs * pImage->GetBitsPerPixel() / 8 + ys * pImage->GetBytesPerLine();
                for (tInt i = 0; i < y2; i++)
                {
                    glRasterPos2i(x1, y1 + i);
                    glDrawPixels(x2, 1, l_nFormat, GL_UNSIGNED_BYTE, pData);
                    pData += pImage->GetBytesPerLine();
                }
                glPixelZoom(1.0, 1.0);
                // glDrawPixels(pImage->GetWidth()-1, pImage->GetHeight()-1, l_nFormat, GL_UNSIGNED_BYTE,
                // (tUInt8*)pBitmap + 3 + 64*3);
            }
        }
    }
 
    tVoid Capture(IImage** ppImage, tInt x, tInt y, tInt nWidth, tInt nHeight) override
    {
        if (nWidth <= 0)
        {
            nWidth = m_nWidth;
        }
 
        if (nHeight <= 0)
        {
            nHeight = m_nHeight;
        }
 
        if (m_oCaptureBuffer.GetWidth() != nWidth || m_oCaptureBuffer.GetHeight() != nHeight)
        {
            m_oCaptureBuffer.Create(nWidth, nHeight, 32, 0, NULL, IImage::PF_RGBA_8888);
        }
 
        glFlush();
        glFinish();
        glPixelStorei(GL_PACK_ROW_LENGTH, nWidth);
        glPixelStorei(GL_PACK_ALIGNMENT, 4);
        glReadBuffer(GL_BACK);
 
        glReadPixels(x, y, nWidth, nHeight, GL_BGR, GL_UNSIGNED_BYTE, m_oCaptureBuffer.GetBitmap());
 
        m_oCaptureBuffer.Flip();
 
        *ppImage = (IImage*) &m_oCaptureBuffer;
    }
 
    IScene* BeginScene() override
    {
        glDepthMask(GL_FALSE);
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
 
        m_nMode = COORDS_LOGICAL;
 
        return NULL;
    }
 
    tVoid EndScene() override
    {
        SwitchToScreenCoords();
 
        glDepthMask(GL_TRUE);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_CULL_FACE);
        glDisable(GL_LIGHTING);
 
        m_nMode = COORDS_SCREEN;
    }
 
    tVoid SetFlag(tUInt32 nFlag, tInt32 nValue)
    {
        switch (nFlag)
        {
            case CANVAS_FLAG_TEXT_FLIP_HORIZONTALLY:
            {
                m_oCurrentFlags.bTextOppsedYAxis = nValue != 0;
            }
            break;
            case CANVAS_FLAG_TEXT_SCALE_WITH_COORDINATE_SYSTEM:
            {
                m_oCurrentFlags.bTextScales = nValue != 0;
            }
            break;
            case CANVAS_FLAG_TEXT_ROTATE_WITH_COORDINATE_SYSTEM:
            {
                m_oCurrentFlags.bTextRotate = nValue != 0;
            }
            break;
            case CANVAS_FLAG_TEXT_BASELINE_ON_TOP:
            {
                m_oCurrentFlags.bTextBaselineOnTop = nValue != 0;
            }
            break;
            default:
            {
            }
        }
    }
 
    tInt32 GetFlag(tUInt32 nFlag)
    {
        switch (nFlag)
        {
            case CANVAS_FLAG_TEXT_FLIP_HORIZONTALLY:
            {
                return m_oCurrentFlags.bTextOppsedYAxis ? 1 : 0;
            }
            break;
            case CANVAS_FLAG_TEXT_SCALE_WITH_COORDINATE_SYSTEM:
            {
                return m_oCurrentFlags.bTextScales ? 1 : 0;
            }
            break;
            case CANVAS_FLAG_TEXT_ROTATE_WITH_COORDINATE_SYSTEM:
            {
                return m_oCurrentFlags.bTextRotate ? 1 : 0;
            }
            break;
            case CANVAS_FLAG_TEXT_BASELINE_ON_TOP:
            {
                return m_oCurrentFlags.bTextBaselineOnTop ? 1 : 0;
            }
            break;
            default:
            {
            }
        }
        return 0;
    }
 
    tResult PushFlags()
    {
        if (m_oFlags.size() > 20)
        {
            RETURN_ERROR(ERR_OUT_OF_RANGE);
        }
 
        m_oFlags.push(m_oCurrentFlags);
 
        RETURN_NOERROR;
    };
 
    tResult PopFlags()
    {
        if (m_oFlags.size() == 0)
        {
            RETURN_ERROR(ERR_OUT_OF_RANGE);
        }
 
        m_oCurrentFlags = m_oFlags.top();
        m_oFlags.pop();
 
        RETURN_NOERROR;
    };
 
    tVoid ResetFlags()
    {
        m_oCurrentFlags.bTextRotate = tFalse;
        m_oCurrentFlags.bTextOppsedYAxis = tTrue;
        m_oCurrentFlags.bTextScales = tFalse;
        m_oCurrentFlags.bTextBaselineOnTop = tFalse;
    };
 
    tVoid DrawEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle)
    {
        DrawEllipse((tFloat32) iOriginX, (tFloat32) iOriginY, (tFloat32) iWidth, (tFloat32) iHeight, (tFloat32) iAngle);
    }
 
    tVoid
        DrawEllipse(tFloat32 f32OriginX, tFloat32 f32OriginY, tFloat32 f32Width, tFloat32 f32Height, tFloat32 f32Angle)
    {
        tFloat32 x1 = -f32Width / 2;
        tFloat32 x2 = f32Width / 2;
        tFloat32 y1 = -f32Height / 2;
        tFloat32 y2 = f32Height / 2;
 
        glPushMatrix();
 
        glTranslatef(f32OriginX, f32OriginY, 0.0f);
        glRotatef(-f32Angle, 0.0f, 0.0f, 1.0f);
 
        DrawCircle(x1, y1, x2, y2);
 
        glPopMatrix();
    }
 
    tVoid FillEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle)
    {
        FillEllipse((tFloat32) iOriginX, (tFloat32) iOriginY, (tFloat32) iWidth, (tFloat32) iHeight, (tFloat32) iAngle);
    }
 
    tVoid
        FillEllipse(tFloat32 f32OriginX, tFloat32 f32OriginY, tFloat32 f32Width, tFloat32 f32Height, tFloat32 f32Angle)
    {
        tFloat32 x1 = -f32Width / 2;
        tFloat32 x2 = f32Width / 2;
        tFloat32 y1 = -f32Height / 2;
        tFloat32 y2 = f32Height / 2;
 
        glPushMatrix();
 
        glTranslatef(f32OriginX, f32OriginY, 0.0f);
        glRotatef(-f32Angle, 0.0f, 0.0f, 1.0f);
 
        FillCircle(x1, y1, x2, y2);
 
        glPopMatrix();
    }
 
    tVoid PushMatrix()
    {
        glPushMatrix();
    }
 
    tVoid PopMatrix()
    {
        glPopMatrix();
    }
 
    tVoid Translate(tFloat fx, tFloat fy, tFloat fz)
    {
        glTranslated(fx, fy, fz);
    }
 
    tVoid Scale(tFloat fx, tFloat fy, tFloat fz)
    {
        glScaled(fx, fy, fz);
    }
 
    tVoid Rotate(tFloat fangle, tFloat fx, tFloat fy, tFloat fz)
    {
        glRotated(fangle, fx, fy, fz);
    }
 
protected:
    tVoid CoordLine(tInt x1, tInt y1, tInt x2, tInt y2) const
    {
        glVertex2i(x1, y1);
        glVertex2i(x2, y2);
    }

    tVoid CoordRect(tInt x1, tInt y1, tInt x2, tInt y2) const
    {
        glVertex2i(x1, y1);
        glVertex2i(x2, y1);
        glVertex2i(x2, y2);
        glVertex2i(x1, y2);
    }

    tVoid CoordCircle(tInt x1, tInt y1, tInt x2, tInt y2) const
    {
        CoordCircle((tFloat32) x1, (tFloat32) y1, (tFloat32) x2, (tFloat32) y2);
    }

    tVoid CoordCircleSegment(tInt x1, tInt y1, tInt x2, tInt y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) const
    {
        CoordCircleSegment((tFloat32) x1, (tFloat32) y1, (tFloat32) x2, (tFloat32) y2, fDegreeStart, fDegreeEnd);
    }

    tVoid CoordLine(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) const
    {
        glVertex2f(x1, y1);
        glVertex2f(x2, y2);
    }

    tVoid CoordRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) const
    {
        glVertex2f(x1, y1);
        glVertex2f(x2, y1);
        glVertex2f(x2, y2);
        glVertex2f(x1, y2);
    }

    tVoid CoordCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) const
    {
        tFloat64 fRadX = (tFloat64) (x2 - x1) / 2.0;
        tFloat64 fRadY = (tFloat64) - (y2 - y1) / 2.0;
        tFloat32 nCenterX = (x1 + x2) / 2.0f;
        tFloat32 nCenterY = (y1 + y2) / 2.0f;
 
        tFloat32 l_fRadDist = (tFloat32) (fRadX + fRadY) / 2.0f;
        tInt l_nSegments = 32 + tInt(l_fRadDist / 4.0f);
        tInt l_nStep = (tInt) (PI * 2.0 / l_nSegments);
        if (l_nStep < 1)
        {
            l_nStep = 1;
        }
 
        const tFloat64 fDeg2Rad = PI / 180.0;
 
        for (tInt w = 0; w < 360 + l_nStep; w += l_nStep)
        {
            glVertex2f(nCenterX + (tFloat32) (fRadX * sin(w * fDeg2Rad)),
                       nCenterY + (tFloat32) (fRadY * cos(w * fDeg2Rad)));
        }
    }

    tVoid CoordCircleSegment(
        tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) const
    {
        tFloat64 fRadX = (tFloat64) (x2 - x1) / 2.0;
        tFloat64 fRadY = (tFloat64) - (y2 - y1) / 2.0;
        tFloat64 fCenterX = (x1 + x2) / 2;
        tFloat64 fCenterY = (y1 + y2) / 2;
 
        tFloat64 l_fRadDist = (fRadX + fRadY / 2.0);
        tInt l_nSegments = 32 + tInt(l_fRadDist / 4.0);
        tInt l_nStep = (tInt) (PI * 2.0 / l_nSegments);
        if (l_nStep < 1)
        {
            l_nStep = 1;
        }
 
        tInt nDegreeStart = (tInt) (fDegreeStart + 0.9999) % 360;
        tInt nDegreeEnd = (tInt) (fDegreeEnd);
        if (nDegreeEnd < nDegreeStart)
        {
            nDegreeEnd = nDegreeStart + 360;
        }
 
        const tFloat64 fDeg2Rad = PI / 180.0;
 
        glVertex2f(GLfloat(fCenterX + (tFloat32) (fRadX * sin(fDegreeStart * fDeg2Rad))),
                   GLfloat(fCenterY + (tFloat32) (fRadY * cos(fDegreeStart * fDeg2Rad))));
 
        for (tInt w = nDegreeStart; w < nDegreeEnd; w += l_nStep)
        {
            glVertex2f(GLfloat(fCenterX + static_cast<tFloat32>(fRadX * sin(w * fDeg2Rad))),
                       GLfloat(fCenterY + static_cast<tFloat32>(fRadY * cos(w * fDeg2Rad))));
        }
 
        glVertex2f(GLfloat(fCenterX + (tFloat32) (fRadX * sin(fDegreeEnd * fDeg2Rad))),
                   GLfloat(fCenterY + (tFloat32) (fRadY * cos(fDegreeEnd * fDeg2Rad))));
    }

    tVoid SwitchToScreenCoords()
    {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
 
        GLdouble const zNear = -1.0;
        GLdouble const zFar = 1.0;
 
        if (m_bUseMapping)
        {
            GLdouble const x1 = m_f32MappingX1;
            GLdouble const y1 = m_f32MappingY1;
            GLdouble const x2 = m_f32MappingX2;
            GLdouble const y2 = m_f32MappingY2;
            glOrtho(x1, x2, y2, y1, zNear, zFar);
        }
        else
        {
            GLdouble const x1 = 0;
            GLdouble const y1 = 0;
            GLdouble const x2 = m_nWidth;
            GLdouble const y2 = m_nHeight;
            glOrtho(x1, x2, y2, y1, zNear, zFar);
        }
 
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
    }
};
 
} // namespace dengar
 
using dengar::cGLCanvas;
 
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf