gl2d_canvas_interface.h

Go to the documentation of this file.

#ifndef SDK_GL2D_CANVAS_INTERFACE_H_
#define SDK_GL2D_CANVAS_INTERFACE_H_
#pragma once
 
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
#include <base/inc/sdk_component_base.h>
#include <base/inc/sdk_results_enum.h>
#include <base/inc/geometry/geometry_base_types.h>
#include <base/inc/color/color_base_types.h>
#include <base/inc/math/matrix_base_types.h>
#include <base/inc/interfaces/properties/properties_interface.h>
#include <visualizationlayer/inc/vis_const.h>
 
#include "./gl2d_canvas_func/gl2d_canvas_utils_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_projection_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_palette_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_radar_image_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_filled_circles_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_pattern_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_textbox_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_bordered_latin1_text_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_latin1_text_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_text_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_line_mark_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_sprites_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_textured_line_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_texture_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_light_source_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_mesh_func_interface.h"
#include "./gl2d_canvas_func/gl2d_canvas_line_func_interface.h"
 
#include "gl2d_caps_interface.h"
#include "gl2d_stats_interface.h"
#include "gl2d_draw_stats_interface.h"
#include "gl2d_textures_storage_interface.h"
#include "gl2d_font_interface.h"
#include "gl2d_clip_rule_interface.h"
#include "gl2d_thread_interface.h"
#include "gl2d_objects.h"
 
// Disable some of very noisy GCC warnings
#if defined (SDK_CC_GCC)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wextra"
#endif // SDK_CC_GCC
 
SDK_GL2D_BEGIN_NAMESPACE
 
FWD_DECL_INTERFACE(IGL2DFactory);
FWD_DECL_INTERFACE(IGL2DFontsStorage);
FWD_DECL_INTERFACE(IGL2DCanvasDrawLock);
FWD_DECL_INTERFACE(IGL2DCanvas);
 
static const SDKColorF kGL2DTransparentClr = { 0.0f, 0.0f, 0.0f, 0.0f };
static const SDKColorF kGL2DWhiteClr = { 1.0f, 1.0f, 1.0f, 1.0f };
 
static const SDKVertex3D kGL2DUndefinedPosition =
  { SDK_MAX_FLOAT, SDK_MAX_FLOAT, -SDK_MAX_FLOAT };
 
enum GL2DCanvasPropertyIDs
{
  kGL2DCanvasPropertyID_RootShadersFolder              = 0,
 
  kGL2DCanvasPropertyID_DPI                            = 1,
 
  kGL2DCanvasPropertyID_DefAntiAliasingWidth           = 2,
 
  kGL2DCanvasPropertyID_DefFontBorderWidth             = 3,
 
  kGL2DCanvasPropertyID_DefLineSmoothAngle             = 4,
 
  kGL2DCanvasPropertyID_DefLineRoundAngle              = 5,
 
  kGL2DCanvasPropertyID_RemoveClipRuleOnDrawFinished   = 6,
 
  kGL2DCanvasPropertyID_DontCreateNonRenderableObjects = 7,
 
  kGL2DCanvasPropertyID_AllowCreateCompatibleObject    = 8,
 
  kGL2DCanvasPropertyID_AdjustTextPosition             = 9,
 
  kGL2DCanvasPropertyID_AdjustLatin1TextPosition       = 10,
 
  kGL2DCanvasPropertyID_TextsBlurring                  = 11,
 
  kGL2DCanvasPropertyID_MaxOzCoordinateValue           = 12,
 
  kGL2DCanvasPropertyID_CurrentDrawCycleNum            = 13,
 
  kGL2DCanvasPropertyID_AutoAcquireReleaseDrawLock     = 14,
 
 
  kGL2DCanvasPropertyID_PolygonsAsLines                = 100,
 
  kGL2DCanvasPropertyID_Use32BitsTexturesForTexts      = 101,
 
  kGL2DCanvasPropertyID_TextTexturesAtlasBlockSize     = 102,
  
  kGL2DCanvasPropertyID_TextTexturesAtlasTextureWidth  = 103,
 
  kGL2DCanvasPropertyID_TextTexturesAtlasTextureHeight = 104,
 
  kGL2DCanvasPropertyID_AllowExpandSymbolTexture       = 105,
 
  kGL2DCanvasPropertyID_UseHighPriorityForGLThreads    = 106,
 
  kGL2DCanvasPropertyID_CacheCleanupTimeout            = 107,
 
  kGL2DCanvasPropertyID_CachedSymbolsCount             = 108,
 
  kGL2DCanvasPropertyID_CachedCharMapsCount            = 109,
 
  kGL2DCanvasPropertyID_CachedGLBuffersCount           = 110,
 
  kGL2DCanvasPropertyID_Private                        = 1000,
};
 
enum GL2DPlatformType
{
  // WGL, Windows only (Internally created and managed context)
  kGL2DPlatformType_WGL               = 0,
 
  // EGL, Linux/Android only (Internally created and managed context)
  kGL2DPlatformType_EGL               = 1, 
 
  // Mesa, Linux only (Internally created and managed context)
  kGL2DPlatformType_Mesa              = 2, 
 
  // GLX, Linux only (Internally created and managed context)
  kGL2DPlatformType_GLX               = 3, 
 
  // Platform type is unknown due of given context was created by 
  // external application. But GL2D controls lifetime of given context 
  // by calling create/destroy methods and can activate/deactivate it as well
  // See IGL2DExtCreatedGlCtx description
  kGL2DPlatformType_ExternallyCreated = 4,
 
  // Platform type is unknown due of given context is fully controlled by 
  // external application. It's assumed that external application also 
  // keeps given context as active in appropriate thread, which was passed via
  // appropriate set of initial parameters:
  // kGL2DCreateCanvasSettingIDs_GlThread - Thread to use for any of GL operation
  //    This thread should ALWAYS have active OpenGL context, it is not allowed
  //    to attach different OpenGL contexts to given thread.
  // kGL2DCreateCanvasSettingIDs_GetGlProcAddr - glGetProcAddress method entry point
  // kGL2DCreateCanvasSettingIDs_GlLibHandle - Handle to appropriate OpenGL library
  kGL2DPlatformType_ExternallyManaged = 5, 
};
 
enum GL2DCanvasType
{
  kGL2DCanvasType_Auto       = 0, // Auto select canvas type
  kGL2DCanvasType_OpenGL     = 1, // OpenGL
  kGL2DCanvasType_OpenGL_ES2 = 2, // OpenGL ES2
};
 
enum GL2DDeviceType
{
  // Unknown device
  kGL2DDeviceType_Unknown                          = 0x00000000L,
                                                   
  // List of available generic devices             
  // Generic desktop device (Windows/Linux)        
  kGL2DDeviceType_Generic_Desktop                  = 0x00000001L,
  // Generic Android based device                  
  kGL2DDeviceType_Generic_Android                  = 0x00000002L,
  // Generic iOS based device                      
  kGL2DDeviceType_Generic_iOS                      = 0x00000003L,
                                                 
  // List of specific devices                    
  // iMX6 based device                           
  kGL2DDeviceType_iMX6                             = 0x00001000L,
 
  // List of test devices, you'll not see most of them in real life 
  // unless you are a Navtor developer
  // Main device to use for UnitTests (Windows for now)
  // MacBook Pro 16.1 with AMD Radeon 5500M, running on Windows 10
  kGL2DDeviceType_BSA_Laptop                       = 0x80000000L,
  // Test device use for MESA/EGL/GLX based unittests for Desktop Linux
  // Ubuntu 19.04, running on VMWare
  kGL2DDeviceType_DesktopLinux_TestDevice          = 0x80000001L,
  // Test device to perform unittests for iMX6 platform
  // Navico device with GC2000 videoadapter
  kGL2DDeviceType_iMX6_TestDevice                  = 0x80000002L,
  // Test device to perform unittests for Android platform
  // Samsung Galaxy S3 with Mali-400 MP videoadapter
  kGL2DDeviceType_Android_TestDevice_SGS3          = 0x80000003L,
  // Test device to perform unittests for Android platform
  // Sony Xperia Z with Adreno 320 videoadapter
  kGL2DDeviceType_Android_TestDevice_XperiaZ       = 0x80000004L,
  // Test device to perform unittests for Android platform
  // Huawei MediaPad M5 Pro with Mali-G71 videoadapter
  kGL2DDeviceType_Android_TestDevice_MediaPadM5Pro = 0x80000005L,
};
 
enum GL2DCacheType
{
  // NULL cache type
  kGL2DCacheType_None            = 0x00000000UL,
 
  // Symbols (letters) textures
  kGL2DCacheType_SymbolsTextures = 0x00000001UL,
  // Latin1 characters maps (set of letters) textures
  kGL2DCacheType_CharMapTextures = 0x00000002UL,
  // OpenGL buffers (VBO)
  kGL2DCacheType_GLBuffers       = 0x00000004UL,
 
  // All available cache types
  kGL2DCacheType_All             = kGL2DCacheType_SymbolsTextures |
                                   kGL2DCacheType_CharMapTextures |
                                   kGL2DCacheType_GLBuffers,
};
 
enum GL2DCreateCanvasSettingIDs
{
  // Following set of parameters should be defined in case requested
  //  GL2DPlatformType is equal to kGL2DPlatformType_ExternallyManaged
  // Either no parameters should be defined or all of them
 
  kGL2DCreateCanvasSettingIDs_GlThread                        = 1,
 
  kGL2DCreateCanvasSettingIDs_GetGlProcAddr                   = 2,
 
  kGL2DCreateCanvasSettingIDs_GlLibHandle                     = 3,
 
  // Following set of parameters should be defined in case requested
  //  GL2DPlatformType is equal to kGL2DPlatformType_ExternallyCreated
  // Either no parameters should be defined or all of them
 
  kGL2DCreateCanvasSettingIDs_ExtCreatedCtx                   = 4,
 
  // Common parameters
 
  kGL2DCreateCanvasSettingIDs_UseSameCtxForResourceAndDrawing = 10,
 
  kGL2DCreateCanvasSettingIDs_LogDirectory                    = 100,
  
  kGL2DCreateCanvasSettingIDs_CheckGlCalls                    = 101,
 
  kGL2DCreateCanvasSettingIDs_BreakOnGlError                  = 102,
 
  kGL2DCreateCanvasSettingIDs_LogGlCalls                      = 103,
 
  kGL2DCreateCanvasSettingIDs_LogGlCallPerf                   = 104,
 
  kGL2DCreateCanvasSettingIDs_LogGlTasks                      = 105,
 
  kGL2DCreateCanvasSettingIDs_LogGlThreadUsage                = 106,
 
  kGL2DCreateCanvasSettingIDs_DebugContext                    = 1000,
};
typedef SDKPropertiesSP IGL2DCreateCanvasSettingsSP;
 
class AutoLockUnlockCanvas;
class AutoStartFinishDraw;
class AutoApplyObjectsMatrix;
class AutoApplyCanvasClipRule;
 
static const float kGL2DCanvasDefTextBorderWidth = 2.0f;
 
class IGL2DCanvas : public ISDKProperties,
                    public IGL2DCanvasUtils,
                    public IGL2DCanvasProjectionFunc,
                    public IGL2DCanvasPaletteFunc,
                    public IGL2DCanvasRadarImageFunc,
                    public IGL2DCanvasFilledCirclesFunc,
                    public IGL2DCanvasPatternFunc,
                    public IGL2DCanvasTextBoxFunc,
                    public IGL2DCanvasBorderedLatin1TextFunc,
                    public IGL2DCanvasLatin1TextFunc,
                    public IGL2DCanvasTextFunc,
                    public IGL2DCanvasLineMarkFunc,
                    public IGL2DCanvasSpritesFunc,
                    public IGL2DCanvasTexturedLineFunc,
                    public IGL2DCanvasTextureFunc,
                    public IGL2DCanvasLightSourceFunc,
                    public IGL2DCanvasMeshFunc,
                    public IGL2DCanvasLineFunc
{
public:
  virtual void SDK_CALLTYPE Dump() const throw() = 0;
 
  virtual IGL2DFactorySP SDK_CALLTYPE GetParent() const throw() = 0;
  virtual IGL2DFontsStorageSP SDK_CALLTYPE GetFontsStorage() const throw() = 0;
  virtual IGL2DCanvasDrawLockSP SDK_CALLTYPE GetDrawLock() const throw() = 0;
 
  virtual GL2DPlatformType SDK_CALLTYPE GetPlatformType() const throw() = 0;
  virtual GL2DCanvasType SDK_CALLTYPE GetCanvasType() const throw() = 0;
  virtual GL2DDeviceType SDK_CALLTYPE GetDeviceType() const throw() = 0;
 
  virtual IGL2DCapsSP SDK_CALLTYPE GetCaps() const throw() = 0;
  virtual IGL2DStatsSP SDK_CALLTYPE GetStats() const throw() = 0;
 
  inline bool IsCanvasOperationSupported(
    const GL2DCanvasOperationType& type) const
  {
    const IGL2DCapsSP caps = GetCaps();
    return caps ? caps->IsCanvasOperationSupported(type) : false;
  }
 
  virtual SDKResult SDK_CALLTYPE LockCanvas(
    const bool& release_internal_contexts) throw() = 0;
  virtual SDKResult SDK_CALLTYPE UnLockCanvas() throw() = 0;
  virtual bool SDK_CALLTYPE IsCanvasLocked() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE ForceUnlockAndResume() throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetResourceGlContext(
    GlCtx& resource_ctx) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE GetDrawingGlContext(
    GlCtx& drawing_ctx) const throw() = 0;
 
  virtual bool SDK_CALLTYPE IsSameContextForDrawingAndResources() const throw() = 0;
  inline bool SDK_CALLTYPE IsSeparateContextsForDrawingAndResources() const
  { return !IsSameContextForDrawingAndResources(); }
 
  virtual SDKResult SDK_CALLTYPE EnsureGLDataLoaded() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE ClearUpCache(
    const SDKUInt32& cache_id) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE ReduceCacheSize(
    const SDKUInt32& cache_id, const SDKUInt64& size_to_reduce) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE CreateTexturesStorage(
    IGL2DTexturesStorageSP& textures_storage) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE DrawTexturesToTexture(
    const IGL2DTextureSP& output_texture, 
    const SDKMatrix3X2& canvas_transformation, 
    const SDKColorF& output_tex_clear_color,
    const IGL2DTexturesStorageSP& textures_to_render) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE StartDraw(
    const IGL2DTextureSP& texture) throw() = 0;
  virtual SDKResult SDK_CALLTYPE FinishDraw(const bool& with_glfinish) throw() = 0;
  inline SDKResult SDK_CALLTYPE FinishDraw()
  { return FinishDraw(true); }
  virtual bool SDK_CALLTYPE IsDrawStarted() const throw() = 0;
 
  virtual IGL2DDrawStatsSP SDK_CALLTYPE GetDrawStats() const throw() = 0;
 
  virtual IGL2DTextureSP SDK_CALLTYPE CloneActiveFboBackBuffer() const throw() = 0;
 
  virtual SDKSize SDK_CALLTYPE GetSize() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE ToggleAntiAliasing(
    const bool& is_enabled) throw() = 0;
  virtual bool SDK_CALLTYPE IsAntiAliasingEnabled() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE Clear(const SDKColorF& clr) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE PushObjectsTransformationMatrix(
    const SDKMatrix3X2& matrix) throw() = 0;
  virtual SDKResult SDK_CALLTYPE PopObjectsTransformationMatrix() throw() = 0;
  virtual SDKResult SDK_CALLTYPE RemoveObjectsTransformationMatrixes() throw() = 0;
  virtual SDKResult SDK_CALLTYPE GetObjectsTransformationMatrix(
    SDKMatrix3X2& matrix) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE SetCanvasTransformationMatrix(
    const SDKMatrix3X2& matrix) throw() = 0;
  virtual SDKResult SDK_CALLTYPE ApplyCanvasTransformationMatrix(
    const SDKMatrix3X2& matrix) throw() = 0;
  virtual SDKResult SDK_CALLTYPE GetCanvasTransformationMatrix(
    SDKMatrix3X2& matrix) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE RemoveTransformationMatrixes() throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetTotalTransformationMatrix(
    SDKMatrix3X2& matrix) const throw() = 0;
 
  virtual IGL2DClipRuleSP SDK_CALLTYPE CreateClipRule(
    const GL2DClipRuleType& type) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE SetClipRule(
    const IGL2DClipRuleSP& rule) throw() = 0;
  virtual IGL2DClipRuleSP SDK_CALLTYPE GetClipRule() const throw() = 0;
  inline SDKResult SDK_CALLTYPE ResetClipRule()
  { return SetClipRule(IGL2DClipRuleSP()); }
 
  virtual SDKAtomicRefCount SDK_CALLTYPE AddRef() const throw() = 0;
  virtual SDKAtomicRefCount SDK_CALLTYPE Release() const throw() = 0;
  virtual SDKResult SDK_CALLTYPE GetInterface(
    const InterfaceId& id, void** obj_ptr) throw() = 0;
 
  SDK_IMPLEMENT_IID(IGL2DCanvas)
  SDK_END_INTERFACE(IGL2DCanvas)
};
SDK_DECLARE_IID(IGL2DCanvas)
 
class AutoLockUnlockCanvas
{
public:
  AutoLockUnlockCanvas(const IGL2DCanvasSP& canvas, const bool& release_ctx)
    : m_canvas(canvas), m_locked(false)
  {
    if (m_canvas && !m_canvas->IsCanvasLocked())
      m_locked = SDK_SUCCEEDED(m_canvas->LockCanvas(release_ctx));
  }
 
  virtual ~AutoLockUnlockCanvas()
  { if (m_locked) m_canvas->UnLockCanvas(); }
 
  inline bool IsLocked() const
  { return m_canvas ? m_canvas->IsCanvasLocked() : false; }
 
private:
  const IGL2DCanvasSP m_canvas;
  bool                m_locked;
};
 
class AutoStartFinishDraw
{
public:
  AutoStartFinishDraw(const IGL2DCanvasSP& canvas, const IGL2DTextureSP& tex)
    : m_canvas(canvas), m_started(false), m_with_glfinish(true)
  {
    if (m_canvas && !m_canvas->IsDrawStarted())
      m_started = SDK_SUCCEEDED(m_canvas->StartDraw(tex));
  }
  AutoStartFinishDraw(const IGL2DCanvasSP& canvas, const IGL2DTextureSP& tex, 
    const bool& with_glfinish)
    : m_canvas(canvas), m_started(false), m_with_glfinish(with_glfinish)
  {
    if (m_canvas && !m_canvas->IsDrawStarted())
      m_started = SDK_SUCCEEDED(m_canvas->StartDraw(tex));
  }
 
  virtual ~AutoStartFinishDraw()
  { if (m_started) m_canvas->FinishDraw(m_with_glfinish); }
 
  inline bool IsStarted() const
  { return m_canvas ? m_canvas->IsDrawStarted() : false; }
 
private:
  const IGL2DCanvasSP m_canvas;
  bool                m_started;
  bool                m_with_glfinish;
};
 
class AutoApplyObjectsMatrix
{
public:
  AutoApplyObjectsMatrix(const IGL2DCanvasSP& canvas, const SDKMatrix3X2& m)
    : m_canvas(canvas), m_applied(false)
  {
    if (canvas)
      m_applied = SDK_SUCCEEDED(m_canvas->PushObjectsTransformationMatrix(m));
  }
 
  virtual ~AutoApplyObjectsMatrix()
  { if (m_applied) m_canvas->PopObjectsTransformationMatrix(); }
 
  inline bool IsApplied() const
  { return m_applied; }
 
private:
  const IGL2DCanvasSP m_canvas;
  bool                m_applied;
};
 
class AutoApplyCanvasClipRule
{
public:
  AutoApplyCanvasClipRule(const IGL2DCanvasSP& canvas, const IGL2DClipRuleSP& rule)
    : m_canvas(canvas), m_applied(false)
  {
    if (canvas)
      m_applied = SDK_SUCCEEDED(m_canvas->SetClipRule(rule));
  }
 
  virtual ~AutoApplyCanvasClipRule()
  { if (m_applied) m_canvas->ResetClipRule(); }
 
  inline bool IsApplied() const
  { return m_applied; }
 
private:
  const IGL2DCanvasSP m_canvas;
  bool                m_applied;
};
 
SDK_GL2D_END_NAMESPACE
 
#if defined (SDK_CC_GCC)
# pragma GCC diagnostic pop
#endif // SDK_CC_GCC
 
#endif // SDK_GL2D_CANVAS_INTERFACE_H_