gfxlibinterfaces.h

Go to the documentation of this file.

#pragma once
#undef CreateFont
#include <adtfdisplaytoolboxgraphics/color_intf.h>
#include <adtfdisplaytoolboxgraphics/image_intf.h>
#include <adtfdisplaytoolboxgraphics/rect_intf.h>
#include <adtfdisplaytoolboxgraphics/vector3_intf.h>
#include <adtf_utils.h>
#include <adtf_ucom3.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{

#define COORDS_NONE 0x00

#define COORDS_SCREEN 0x01

#define COORDS_LOGICAL 0x02
 
namespace dengar
{

class IGraphicsFlags
{
public:
    enum
    {
        DEVICE_GDI = 0x0001,
        DEVICE_QT = 0x0002,
        DEVICE_SWT = 0x0004,
        DEVICE_X11 = 0x0008,
        DEVICE_SDL = 0x0010,
        // ---------------------------------------------------------------------
        SUPPORT_OPENGL = 0x0100,
        FULLSCREEN_MODE = 0x0200,
        SUPPORT_ADTF25 = 0x0400
    };
};

class IFont
{
public:
    typedef enum
    {
        STYLE_Default,
        STYLE_Antialiased,
        STYLE_Mono
    } tStyle;
 
public:
    virtual ~IFont()
    {
    }

    virtual tResult Release() = 0;

    virtual tInt GetHeight() const = 0;

    virtual tBool MeasureText(const tChar* str, tInt& nWidth, tInt& nHeight) const = 0;
};

class ITexture
{
public:
    typedef enum
    {
        MODE_BilinearFiltered,
        MODE_NearestPixel
    } tTextureMode;
 
public:
    virtual ~ITexture()
    {
    }

    virtual tResult Release() = 0;

    virtual tResult SetMode(tInt nMode) = 0;

    virtual tVoid MakeCurrent() = 0;

    virtual tResult Copy(IImage* pSource) = 0;

    virtual tInt GetWidth() const = 0;

    virtual tInt GetHeight() const = 0;

    virtual tInt GetBitsPerPixel() const = 0;

    virtual tInt GetPhysicalWidth() const = 0;

    virtual tInt GetPhysicalHeight() const = 0;
};

class IGraphicsMode
{
public:
    typedef enum
    {
        MODE_DrawPoints,
        MODE_DrawLines,
        MODE_DrawLineStrip,
        MODE_DrawLineLoop,
        MODE_DrawTriangles,
        MODE_DrawTriangleStrip,
        MODE_DrawTriangleFan,
        MODE_DrawQuads,
        MODE_DrawQuadStrip,
        MODE_DrawPolygon
    } tMode;

    typedef enum
    {
        FEATURE_AlphaBlending,
        FEATURE_Antialiasing,
        FEATURE_Lighting,
        FEATURE_DepthBuffer,
        FEATURE_BackFaceCulling,
        FEATURE_CommandLists,
        FEATURE_HardwareAcceleration
    } tFeature;
 
public:
    virtual ~IGraphicsMode()
    {
    }

    virtual tBool IsSupported(tFeature nFeatureId) const = 0;

    virtual tVoid EnableAlpha(tBool bAdditiveMode = tFalse) const = 0;

    virtual tVoid DisableAlpha() const = 0;

    virtual tVoid EnableAntialiasing() const = 0;

    virtual tVoid DisableAntialiasing() const = 0;

    virtual tVoid EnableLighting() const = 0;

    virtual tVoid DisableLighting() const = 0;

    virtual tVoid EnableDepthBuffer() const = 0;

    virtual tVoid DisableDepthBuffer() const = 0;

    virtual tVoid EnableBackFaceCulling() const = 0;

    virtual tVoid DisableBackFaceCulling() const = 0;

    virtual tVoid LineWidth(tFloat64 fWidth) = 0;

    virtual tVoid LinePattern(tUInt16 ui16Pattern, tInt nFactor = 1) = 0;

    virtual tVoid Color(const IColor* col) = 0;

    virtual tVoid Color(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 255) = 0;

    virtual tVoid Color(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255) = 0;

    virtual tVoid Color(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 1.0) = 0;

    virtual tVoid BgColor(const IColor* col) = 0;

    virtual tVoid BgColor(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 0) = 0;

    virtual tVoid BgColor(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 0) = 0;

    virtual tVoid BgColor(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 0.0) = 0;

    virtual tVoid Begin(tMode eMode) = 0;

    virtual tVoid Coord(tInt x, tInt y) = 0;

    virtual tVoid Coord(tFloat32 x, tFloat32 y) = 0;

    virtual tVoid Coord(IPoint* pt) = 0;

    virtual tVoid Coord(IPoint** ppPoints, tInt nCount) = 0;

    virtual tVoid CoordTexture(tFloat32 u, tFloat32 v) = 0;

    virtual tVoid End() = 0;
};
 
class IScene;

 
class ICanvas : public IGraphicsMode, public ucom::ant::IObject
{
public:
    ADTF_IID(ICanvas, "canvas.adtf_disptb.iid");

    virtual tResult Create(tInt nWidth, tInt nHeight, tInt nBitsPerPixel) = 0;
 
    virtual tVoid PushMatrix() = 0;
 
    virtual tVoid PopMatrix() = 0;
 
    virtual tVoid Translate(tFloat fx, tFloat fy, tFloat fz) = 0;
 
    virtual tVoid Scale(tFloat fx, tFloat fy, tFloat fz) = 0;
 
    virtual tVoid Rotate(tFloat fangle, tFloat fx, tFloat fy, tFloat fz) = 0;

    virtual tInt GetWidth() const = 0;

    virtual tInt GetHeight() const = 0;

    virtual tInt GetBitsPerPixel() const = 0;

    virtual tVoid SetMapping(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;

    virtual tVoid ClearMapping() = 0;

    virtual tInt MapPixelX(tFloat32 x) = 0;

    virtual tInt MapPixelY(tFloat32 y) = 0;

    virtual tInt MapPixelX(tInt x) = 0;

    virtual tInt MapPixelY(tInt y) = 0;

    virtual tFloat32 UnmapPixelX(tInt x) = 0;

    virtual tFloat32 UnmapPixelY(tInt y) = 0;

    virtual tVoid Clear() = 0;

    virtual tResult CreateTexture(IImage* pImage, ITexture*& pTexture) = 0;

    virtual tVoid DrawTexture(ITexture* pTexture, tFloat32 vPoints[8]) = 0;

    virtual tVoid DrawPixel(tInt x, tInt y) = 0;

    virtual tVoid DrawLine(tInt x1, tInt y1, tInt x2, tInt y2) = 0;

    virtual tVoid DrawRect(tInt x1, tInt y1, tInt x2, tInt y2) = 0;

    virtual tVoid DrawCircle(tInt x1, tInt y1, tInt x2, tInt y2) = 0;

    virtual tVoid DrawCircleSegment(tInt x1,
                                    tInt y1,
                                    tInt x2,
                                    tInt y2,
                                    tFloat64 fDegreeStart,
                                    tFloat64 fDegreeEnd,
                                    tBool bNormalizeRect = tFalse) = 0;

    virtual tVoid FillRect(tInt x1, tInt y1, tInt x2, tInt y2) = 0;

    virtual tVoid FillCircle(tInt x1, tInt y1, tInt x2, tInt y2) = 0;

    virtual tVoid FillCircleSegment(tInt x1,
                                    tInt y1,
                                    tInt x2,
                                    tInt y2,
                                    tFloat64 fDegreeStart,
                                    tFloat64 fDegreeEnd,
                                    tBool bNormalizeRect = tFalse) = 0;

    virtual tVoid DrawPixel(tFloat32 x, tFloat32 y) = 0;

    virtual tVoid DrawLine(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;

    virtual tVoid DrawRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;

    virtual tVoid DrawCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;

    virtual tVoid DrawCircleSegment(tFloat32 x1,
                                    tFloat32 y1,
                                    tFloat32 x2,
                                    tFloat32 y2,
                                    tFloat64 fDegreeStart,
                                    tFloat64 fDegreeEnd,
                                    tBool bNormalizeRect = tFalse) = 0;

    virtual tVoid FillRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;

    virtual tVoid FillCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;

    virtual tVoid FillCircleSegment(tFloat32 x1,
                                    tFloat32 y1,
                                    tFloat32 x2,
                                    tFloat32 y2,
                                    tFloat64 fDegreeStart,
                                    tFloat64 fDegreeEnd,
                                    tBool bNormalizeRect = tFalse) = 0;

    virtual tVoid DrawPixel(IPoint* pt) = 0;

    virtual tVoid DrawLine(IPoint* ptStart, IPoint* ptEnd) = 0;

    virtual tVoid DrawRect(IRect* rect) = 0;

    virtual tVoid DrawPolygon(IPoint** ppPoints, tInt nCount) = 0;

    virtual tVoid DrawCircle(IRect* rect) = 0;

    virtual tVoid DrawCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) = 0;

    virtual tVoid FillRect(IRect* rect) = 0;

    virtual tVoid FillPolygon(IPoint** ppPoints, tInt nCount) = 0;

    virtual tVoid FillCircle(IRect* rect) = 0;

    virtual tVoid FillCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) = 0;

    virtual IFont* CreateFont(const char* strName, tInt nHeight, IFont::tStyle eFontStyle = IFont::STYLE_Default) = 0;

    virtual tVoid SetFontAngle(tFloat64 fAngle) = 0;

    // * Returns the font angle
    // * @return angle of the font
    // */
    virtual tFloat64 GetFontAngle() = 0;

    // * Sets the current font for drawing operations
    // * @param  [in]  pFont    Pointer to font instance
    // * @return  void
    // */
    virtual tVoid Font(IFont* pFont) = 0;

    // * Sets an text to a given position
    // * @param [in] x x position of the text
    // * @param [in] y y position of the text
    // * @param [in] fmt format string the format follows the printf specification
    // * @param [in] ... unspecified parameters described in the format string
    // * @return  void
    // */
    virtual tVoid OutputText(tInt x, tInt y, const tChar* fmt, ...) = 0;

    // * Sets an text to a given position
    // * @param [in] x x position of the text
    // * @param [in] y y position of the text
    // * @param [in] fmt format string the format follows the printf specification
    // * @param [in] ... unspecified parameters described in the format string
    // * @return  void
    // */
    virtual tVoid OutputText(tFloat32 x, tFloat32 y, const tChar* fmt, ...) = 0;

    virtual ITexture* CreateTexture(const tBitmapFormat* psFormat, tInt nMode = 0) = 0;

    virtual tVoid Texture(ITexture* pTexture) = 0;

    virtual tVoid Blit(ITexture* pTexture, tInt x, tInt y, tInt nWidth, tInt nHeight) = 0;

    virtual tVoid Blit(IImage* pImage, tInt x, tInt y, tInt nWidth, tInt nHeight) = 0;

    virtual tVoid Capture(IImage** ppImage, tInt x, tInt y, tInt nWidth, tInt nHeight) = 0;

    virtual IScene* BeginScene() = 0;

    virtual tVoid EndScene() = 0;

    virtual tVoid SetFlag(tUInt32 nFlag, tInt32 nValue) = 0;

    virtual tInt32 GetFlag(tUInt32 nFlag) = 0;

    virtual tResult PushFlags() = 0;

    virtual tResult PopFlags() = 0;

    virtual tVoid ResetFlags() = 0;

    virtual tVoid DrawEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle) = 0;

    virtual tVoid DrawEllipse(
        tFloat32 f32OriginX, tFloat32 f32OriginY, tFloat32 f32Width, tFloat32 f32Height, tFloat32 f32Angle) = 0;

    virtual tVoid FillEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle) = 0;

    virtual tVoid FillEllipse(
        tFloat32 f32OriginX, tFloat32 f32OriginY, tFloat32 f32Width, tFloat32 f32Height, tFloat32 f32Angle) = 0;
};

class IUIEventHandler
{
public:
    typedef enum
    {
        EC_MouseLDown = 1,

        EC_MouseLUp = 2,

        EC_MouseLDblClk = 3,

        EC_MouseRDown = 4,

        EC_MouseRUp = 5,

        EC_MouseRDblClk = 6,

        EC_MouseMDown = 7,

        EC_MouseMUp = 8,

        EC_MouseMDblClk = 9,

        EC_MouseMove = 10,

        EC_MouseWheel = 11,

        EC_KeyDown = 12,
        // EC_KeyDown          = adtf::IKeyEventHandler::EC_KeyDown,

        EC_KeyUp = 13,
        // EC_KeyUp            = adtf::IKeyEventHandler::EC_KeyUp,

        EC_KeyInput = 14
        // EC_KeyInput         = adtf::IKeyEventHandler::EC_KeyInput
 
    } tControlEventCode;

    typedef enum
    {
        MS_LeftButtonDown = 0x1,
        MS_RightButtonDown = 0x2,
        MS_MiddleButtonDown = 0x4,
        MS_CtrlKeyDown = 0x8
    } tMouseState;

    typedef enum
    {
        KS_CtrlKeyDown = 0x1,
        KS_AltKeyDown = 0x2,
        KS_ShiftKeyDown = 0x4
        /*KS_CtrlKeyDown      = adtf::IKeyEventHandler::KS_CtrlKeyDown,
        KS_AltKeyDown       = adtf::IKeyEventHandler::KS_AltKeyDown,
        KS_ShiftKeyDown     = adtf::IKeyEventHandler::KS_ShiftKeyDown*/
    } tKeyState;

    typedef enum
    {
        KEY_ESCAPE = 0x01000000,
        KEY_TAB = 0x01000001,
        KEY_BACKSPACE = 0x01000003,
        KEY_RETURN = 0x01000004,
        KEY_INSERT = 0x01000006,
        KEY_DELETE = 0x01000007,
        KEY_PRINT = 0x01000009,
        KEY_HOME = 0x01000010,
        KEY_END = 0x01000011,
        KEY_LEFT = 0x01000012,
        KEY_UP = 0x01000013,
        KEY_RIGHT = 0x01000014,
        KEY_DOWN = 0x01000015,
        KEY_PAGEUP = 0x01000016,
        KEY_PAGEDOWN = 0x01000017,
        KEY_SPACE = 0x20,
        KEY_NUMLOCK = 0x01000025,

        KEY_F1 = 0x01000030,
        KEY_F2 = 0x01000031,
        KEY_F3 = 0x01000032,
        KEY_F4 = 0x01000033,
        KEY_F5 = 0x01000034,
        KEY_F6 = 0x01000035,
        KEY_F7 = 0x01000036,
        KEY_F8 = 0x01000037,
        KEY_F9 = 0x01000038,
        KEY_F10 = 0x01000039,
        KEY_F11 = 0x0100003a,
        KEY_F12 = 0x0100003b,

        KEY_PLUS = 0x2b,
        KEY_COMMA = 0x2c,
        KEY_MINUS = 0x2d,
        KEY_PERIOD = 0x2e,
 
        KEY_0 = 0x30,
        KEY_1 = 0x31,
        KEY_2 = 0x32,
        KEY_3 = 0x33,
        KEY_4 = 0x34,
        KEY_5 = 0x35,
        KEY_6 = 0x36,
        KEY_7 = 0x37,
        KEY_8 = 0x38,
        KEY_9 = 0x39,
 
        KEY_A = 0x41,
        KEY_B = 0x42,
        KEY_C = 0x43,
        KEY_D = 0x44,
        KEY_E = 0x45,
        KEY_F = 0x46,
        KEY_G = 0x47,
        KEY_H = 0x48,
        KEY_I = 0x49,
        KEY_J = 0x4a,
        KEY_K = 0x4b,
        KEY_L = 0x4c,
        KEY_M = 0x4d,
        KEY_N = 0x4e,
        KEY_O = 0x4f,
        KEY_P = 0x50,
        KEY_Q = 0x51,
        KEY_R = 0x52,
        KEY_S = 0x53,
        KEY_T = 0x54,
        KEY_U = 0x55,
        KEY_V = 0x56,
        KEY_W = 0x57,
        KEY_X = 0x58,
        KEY_Y = 0x59,
        KEY_Z = 0x5a,
 
        KEY_SHIFT = 0x01000020,
        KEY_CTRL = 0x01000021,
        KEY_ALT = 0x01000023
 
        /*///the escape key.
        KEY_ESCAPE       = adtf::IKeyEventHandler::KEY_ESCAPE,
        KEY_TAB          = adtf::IKeyEventHandler::KEY_TAB,
        KEY_BACKSPACE    = adtf::IKeyEventHandler::KEY_BACKSPACE,
        KEY_RETURN       = adtf::IKeyEventHandler::KEY_RETURN,
        KEY_INSERT       = adtf::IKeyEventHandler::KEY_INSERT,
        KEY_DELETE       = adtf::IKeyEventHandler::KEY_DELETE,
        KEY_PRINT        = adtf::IKeyEventHandler::KEY_PRINT,
        KEY_HOME         = adtf::IKeyEventHandler::KEY_HOME,
        KEY_END          = adtf::IKeyEventHandler::KEY_END,
        KEY_LEFT         = adtf::IKeyEventHandler::KEY_LEFT,
        KEY_UP           = adtf::IKeyEventHandler::KEY_UP,
        KEY_RIGHT        = adtf::IKeyEventHandler::KEY_RIGHT,
        KEY_DOWN         = adtf::IKeyEventHandler::KEY_DOWN,
        KEY_PAGEUP       = adtf::IKeyEventHandler::KEY_PAGEUP,
        KEY_PAGEDOWN     = adtf::IKeyEventHandler::KEY_PAGEDOWN,
        KEY_SPACE        = adtf::IKeyEventHandler::KEY_SPACE,
        KEY_NUMLOCK      = adtf::IKeyEventHandler::KEY_NUMLOCK,

        KEY_F1           = adtf::IKeyEventHandler::KEY_F1,
        KEY_F2           = adtf::IKeyEventHandler::KEY_F2,
        KEY_F3           = adtf::IKeyEventHandler::KEY_F3,
        KEY_F4           = adtf::IKeyEventHandler::KEY_F4,
        KEY_F5           = adtf::IKeyEventHandler::KEY_F5,
        KEY_F6           = adtf::IKeyEventHandler::KEY_F6,
        KEY_F7           = adtf::IKeyEventHandler::KEY_F7,
        KEY_F8           = adtf::IKeyEventHandler::KEY_F8,
        KEY_F9           = adtf::IKeyEventHandler::KEY_F9,
        KEY_F10          = adtf::IKeyEventHandler::KEY_F10,
        KEY_F11          = adtf::IKeyEventHandler::KEY_F11,
        KEY_F12          = adtf::IKeyEventHandler::KEY_F12,

        KEY_PLUS         = adtf::IKeyEventHandler::KEY_PLUS,
        KEY_COMMA        = adtf::IKeyEventHandler::KEY_COMMA,
        KEY_MINUS        = adtf::IKeyEventHandler::KEY_MINUS,
        KEY_PERIOD       = adtf::IKeyEventHandler::KEY_PERIOD,
 
        KEY_0            = adtf::IKeyEventHandler::KEY_0,
        KEY_1            = adtf::IKeyEventHandler::KEY_1,
        KEY_2            = adtf::IKeyEventHandler::KEY_2,
        KEY_3            = adtf::IKeyEventHandler::KEY_3,
        KEY_4            = adtf::IKeyEventHandler::KEY_4,
        KEY_5            = adtf::IKeyEventHandler::KEY_5,
        KEY_6            = adtf::IKeyEventHandler::KEY_6,
        KEY_7            = adtf::IKeyEventHandler::KEY_7,
        KEY_8            = adtf::IKeyEventHandler::KEY_8,
        KEY_9            = adtf::IKeyEventHandler::KEY_9,
 
        KEY_A            = adtf::IKeyEventHandler::KEY_A,
        KEY_B            = adtf::IKeyEventHandler::KEY_B,
        KEY_C            = adtf::IKeyEventHandler::KEY_C,
        KEY_D            = adtf::IKeyEventHandler::KEY_D,
        KEY_E            = adtf::IKeyEventHandler::KEY_E,
        KEY_F            = adtf::IKeyEventHandler::KEY_F,
        KEY_G            = adtf::IKeyEventHandler::KEY_G,
        KEY_H            = adtf::IKeyEventHandler::KEY_H,
        KEY_I            = adtf::IKeyEventHandler::KEY_I,
        KEY_J            = adtf::IKeyEventHandler::KEY_J,
        KEY_K            = adtf::IKeyEventHandler::KEY_K,
        KEY_L            = adtf::IKeyEventHandler::KEY_L,
        KEY_M            = adtf::IKeyEventHandler::KEY_M,
        KEY_N            = adtf::IKeyEventHandler::KEY_N,
        KEY_O            = adtf::IKeyEventHandler::KEY_O,
        KEY_P            = adtf::IKeyEventHandler::KEY_P,
        KEY_Q            = adtf::IKeyEventHandler::KEY_Q,
        KEY_R            = adtf::IKeyEventHandler::KEY_R,
        KEY_S            = adtf::IKeyEventHandler::KEY_S,
        KEY_T            = adtf::IKeyEventHandler::KEY_T,
        KEY_U            = adtf::IKeyEventHandler::KEY_U,
        KEY_V            = adtf::IKeyEventHandler::KEY_V,
        KEY_W            = adtf::IKeyEventHandler::KEY_W,
        KEY_X            = adtf::IKeyEventHandler::KEY_X,
        KEY_Y            = adtf::IKeyEventHandler::KEY_Y,
        KEY_Z            = adtf::IKeyEventHandler::KEY_Z,
 
        KEY_SHIFT        = adtf::IKeyEventHandler::KEY_SHIFT,
        KEY_CTRL         = adtf::IKeyEventHandler::KEY_CTRL,
        KEY_ALT          = adtf::IKeyEventHandler::KEY_ALT*/
    } tKey;
 
public:
    virtual tResult OnCreate(tHandle hCanvas, tInt nLeft, tInt nTop, tInt nRight, tInt nBottom) = 0;

    virtual tResult OnPaint(tHandle hCanvas, tInt nLeft, tInt nTop, tInt nRight, tInt nBottom) = 0;

    virtual tResult OnSize(tHandle hCanvas, tInt nLeft, tInt nTop, tInt nRight, tInt nBottom) = 0;

    virtual tResult OnIconify(tHandle hCanvas, tBool bIconified) = 0;

    virtual tResult OnTimer(tHandle hCanvas) = 0;

    virtual tResult OnIdle(tHandle hCanvas) = 0;

    virtual tResult OnDestroy() = 0;

    virtual tResult OnControlEvent(
        tControlEventCode eCode, tInt nParam1 = 0, tInt nParam2 = 0, tInt nFlags = 0, tVoid* pEventData = nullptr) = 0;
};

#define ADTF_VIEWPORT_INTERNAL_CLASS "class"
#define ADTF_VIEWPORT_INTERNAL_TITLEWINDOW "titlewindow"
#define ADTF_VIEWPORT_INTERNAL_PARENT_SETTER "parentset"
 
} // namespace dengar
enum tCanvasFlags
{

    CANVAS_FLAG_TEXT_FLIP_HORIZONTALLY = 1,

    CANVAS_FLAG_TEXT_BASELINE_ON_TOP = 2,

    CANVAS_FLAG_TEXT_SCALE_WITH_COORDINATE_SYSTEM = 4,

    CANVAS_FLAG_TEXT_ROTATE_WITH_COORDINATE_SYSTEM = 8
};
 
using dengar::IGraphicsFlags;
using dengar::IFont;
using dengar::ITexture;
using dengar::ITexture;
using dengar::IGraphicsMode;
using dengar::IScene;
using dengar::ICanvas;
using dengar::IUIEventHandler;
 
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf