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/GL.h>
#else
    #include <GL/gl.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>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{
 
class cGLCanvas : public ucom::catwo::object<ICanvas>
{
 
A_UTILS_D(cGLCanvas)
 
friend class cGLFont;
 
protected:
 
    struct sFlags
    {
        tBool bTextOppsedYAxis; 
        tBool bTextScales; 
        tBool bTextRotate; 
        tBool bTextBaselineOnTop;
    };
 
public:
    
    cGLCanvas();
 
    virtual ~cGLCanvas() final;
 
    tResult Create(tInt nWidth, tInt nHeight, tInt nBitsPerPixel) override;
 
    tResult Resize(tInt nWidth, tInt nHeight);
 
    tResult Release();
 
    tUInt32 GetMode();
 
    tVoid NormalizeRect(tInt& x1, tInt& y1, tInt& x2, tInt& y2) const;
 
    tVoid NormalizeRect(tFloat32& x1, tFloat32& y1, tFloat32& x2, tFloat32& y2) const;
 
    tVoid Coord(tFloat32* pXCoords, tFloat32* pYCoords, tInt nCount);
 
    virtual tVoid FlipTextHorizontally(tBool bOpposedYAxis);
 
    virtual tVoid TextScaleWithZoom(tBool bScaleWithZoom);
    
 
public: // implements IGraphicsMode
    tBool IsSupported(tFeature nFeatureId) const override;
 
    tVoid EnableAlpha(tBool bAdditiveMode = tFalse) const override;
 
    tVoid DisableAlpha() const override;
 
    tVoid EnableAntialiasing() const override;
 
    tVoid DisableAntialiasing() const override;
 
    tVoid EnableLighting() const override;
 
    tVoid DisableLighting() const override;
 
    tVoid EnableDepthBuffer() const override;
 
    tVoid DisableDepthBuffer() const override;
 
    tVoid EnableBackFaceCulling() const override;
 
    tVoid DisableBackFaceCulling() const override;
 
    tVoid LineWidth(tFloat64 fWidth) override;
 
    tVoid LinePattern(tUInt16 ui16Pattern, tInt nFactor = 1) override;
 
    tVoid Color(const IColor* col) override;
 
    tVoid Color(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 255) override;
 
    tVoid Color(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255) override;
 
    tVoid Color(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 1.0) override;
 
    tVoid BgColor(const IColor* col) override;
 
    tVoid BgColor(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 255) override;
 
    tVoid BgColor(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255) override;
 
    tVoid BgColor(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 0.0) override;
 
    tVoid Begin(tMode eMode) override;
 
    tVoid Coord(tInt x, tInt y) override;
 
    tVoid Coord(tFloat32 x, tFloat32 y) override;
 
    tVoid Coord(IPoint* pt) override;
 
    tVoid Coord(IPoint** ppPoints, tInt nCount) override;
 
    tVoid CoordTexture(tFloat32 u, tFloat32 v) override;
 
    tVoid End() override;
 
public: // implements ICanvas
    tInt GetWidth() const override;
 
    tInt GetHeight() const override;
 
    tInt GetBitsPerPixel() const override;
 
    tVoid SetMapping(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override;
 
    tVoid ClearMapping() override;
 
    tInt MapPixelX(tFloat32 x) override;
 
    tInt MapPixelY(tFloat32 y) override;
 
    tInt MapPixelX(tInt x) override;
 
    tInt MapPixelY(tInt y) override;
 
    tFloat32 UnmapPixelX(tInt x) override;
 
    tFloat32 UnmapPixelY(tInt y) override;
 
    tVoid Clear() override;
 
    tResult CreateTexture(IImage* pImage, ITexture*& pTexture) override;
 
    tVoid DrawTexture(ITexture* pTexture, tFloat32 vPoints[8]) override;
 
    tVoid DrawPixel(tInt x, tInt y) override;
 
    tVoid DrawLine(tInt x1, tInt y1, tInt x2, tInt y2) override;
 
    tVoid DrawRect(tInt x1, tInt y1, tInt x2, tInt y2) override;
 
    tVoid DrawCircle(tInt x1, tInt y1, tInt x2, tInt y2) override;
 
    tVoid DrawCircleSegment(tInt x1, tInt y1, tInt x2, tInt y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                            tBool bNormalizeRect = tFalse) override;
 
    tVoid FillRect(tInt x1, tInt y1, tInt x2, tInt y2) override;
 
    tVoid FillCircle(tInt x1, tInt y1, tInt x2, tInt y2) override;
 
    tVoid FillCircleSegment(tInt x1, tInt y1, tInt x2, tInt y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                            tBool bNormalizeRect = tFalse) override;
 
    tVoid DrawPixel(tFloat32 x, tFloat32 y) override;
 
    tVoid DrawLine(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override;
 
    tVoid DrawRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override;
 
    tVoid DrawCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override;
 
    tVoid DrawCircleSegment(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                      tBool bNormalizeRect = tFalse) override;
 
    tVoid FillRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override;
 
    tVoid FillCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) override;
 
    tVoid FillCircleSegment(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                      tBool bNormalizeRect = tFalse) override;
 
    tVoid DrawPixel(IPoint* pt) override;
 
    tVoid DrawLine(IPoint* ptStart, IPoint* ptEnd) override;
 
    tVoid DrawRect(IRect* rect) override;
 
    tVoid DrawPolygon(IPoint** ppPoints, tInt nCount) override;
 
    tVoid DrawCircle(IRect* rect) override;
 
    tVoid DrawCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) override;
 
    tVoid FillRect(IRect* rect) override;
 
    tVoid FillPolygon(IPoint** ppPoints, tInt nCount) override;
 
    tVoid FillCircle(IRect* rect) override;
 
    tVoid FillCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) override;
 
    IFont* CreateFont(const char* strName, tInt nHeight,
                      IFont::tStyle eFontStyle = IFont::STYLE_Default);
 
    tVoid SetFontAngle(tFloat64 fAngle);
 
    tFloat64 GetFontAngle();
 
    tVoid Font(IFont* pFont);
 
    tVoid OutputText(tInt x, tInt y, const char* fmt, ...);
 
    tVoid OutputText(tFloat32 x, tFloat32 y, const char* fmt, ...);
 
    ITexture* CreateTexture(const tBitmapFormat* psFormat, tInt nMode = 0) override;
 
    tVoid Texture(ITexture* pTexture) override;
 
    tVoid Blit(ITexture* pTexture, tInt x, tInt y, tInt nWidth, tInt nHeight) override;
 
    tVoid Blit(IImage* pImage, tInt x, tInt y, tInt nWidth, tInt nHeight) override;
 
    tVoid Capture(IImage** ppImage, tInt x, tInt y, tInt nWidth, tInt nHeight) override;
 
    IScene* BeginScene() override;
 
    tVoid EndScene() override;
 
    tVoid SetFlag(tUInt32 nFlag, tInt32 nValue);
 
    tInt32 GetFlag(tUInt32 nFlag);
 
    tResult PushFlags();
 
    tResult PopFlags();
 
    tVoid ResetFlags();
 
    tVoid DrawEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle);
 
    tVoid DrawEllipse(tFloat32 f32OriginX, tFloat32 f32OriginY, tFloat32 f32Width, tFloat32 f32Height, tFloat32 f32Angle);
 
    tVoid FillEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle);
 
    tVoid FillEllipse(tFloat32 f32OriginX, tFloat32 f32OriginY, tFloat32 f32Width, tFloat32 f32Height, tFloat32 f32Angle);
 
    tVoid PushMatrix();
 
    tVoid PopMatrix();
 
    tVoid Translate(tFloat fx, tFloat fy, tFloat fz) ;
 
    tVoid Scale(tFloat fx, tFloat fy, tFloat fz);
 
    tVoid Rotate(tFloat fangle, tFloat fx, tFloat fy, tFloat fz);
    
 
protected:
    tVoid CoordLine(tInt x1, tInt y1, tInt x2, tInt y2) const;
 
    tVoid CoordRect(tInt x1, tInt y1, tInt x2, tInt y2) const;
 
    tVoid CoordCircle(tInt x1, tInt y1, tInt x2, tInt y2) const;
 
    tVoid CoordCircleSegment(tInt x1, tInt y1, tInt x2, tInt y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) const;
 
    tVoid CoordLine(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) const;
 
    tVoid CoordRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) const;
 
    tVoid CoordCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) const;
 
    tVoid CoordCircleSegment(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2, tFloat64 fDegreeStart,
                             tFloat64 fDegreeEnd) const;
 
    tVoid SwitchToScreenCoords();
 
};
 
}
 
using dengar::cGLCanvas;
 
}
 
}
 
}
 
/// @endcond