2d_render_target_interface.h

Go to the documentation of this file.

#ifndef SDK_2D_RENDER_TARGET_INTERFACE_H_
#define SDK_2D_RENDER_TARGET_INTERFACE_H_
 
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
#include <base/inc/sdk_component_interface.h>
#include <base/inc/color/color_base_types.h>
#include <base/inc/geometry/geometry_base_types.h>
#include <visualizationlayer/inc/scene/texture_interface.h>
#include "2d_graphics_consts.h"
#include "2d_graphics_objects.h"
#include "2d_render_target_bitmap_interface.h"
#include "2d_render_target_brush_interface.h"
#include "2d_render_target_stroke_style_interface.h"
#include "2d_graphics_path_interface.h"
#include "2d_render_target_text_interface.h"
 
namespace sdk {
namespace gfx {
 
typedef enum RenderTarget2DType
{
  RenderTarget2D_Unknown       = 0x00,
 
  RenderTarget2D_Direct2D_DC   = 0x01,
  RenderTarget2D_Direct2D_HWND = 0x02,
  RenderTarget2D_Direct2D_DXGI = 0x03,
  // \brief Render target, based on Direct2D, which renders to Microsoft Windows Imaging Component (WIC) bitmap
  // RenderTarget2D_Direct2D_WIC  = 0x04, // Reserved for future implementation
 
  RenderTarget2D_SKIA_OpenGL_Context = 0x05,
  RenderTarget2D_SKIA_OpenGL_FBO     = 0x06,
  RenderTarget2D_SKIA_OpenGL_Texture = 0x07,
 
  RenderTarget2D_SKIA_Software_Window = 0x08,
  RenderTarget2D_SKIA_Software_Texture = 0x09,
} RenderTarget2DType;
 
class I2DRenderTarget : public sdk::ISDKComponent
{
 public:
  virtual RenderTarget2DType SDK_CALLTYPE GetType() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          GetParent(
    sdk::gfx::RenderTargetFactorySP& parent) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          Reinitialize() throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          GetRenderTargetSize(SDKSize& size) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          SetDPI(const float& dpi_xy) throw() = 0;
  virtual SDKResult SDK_CALLTYPE          GetDPI(float& dpi_xy) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          SetAntiAliasingMode(
    const sdk::gfx::AntiAliasingMode& mode) throw() = 0;
  virtual SDKResult SDK_CALLTYPE          GetAntiAliasingMode(
    sdk::gfx::AntiAliasingMode& mode) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          SetMeasurementUnitsType(
    const sdk::gfx::MeasurementUnits& units_type) throw() = 0;
  virtual SDKResult SDK_CALLTYPE          GetMeasurementUnitsType(
    sdk::gfx::MeasurementUnits& units_type) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          CreateBitmap(
    const sdk::vis::scene::ITextureSP& texture,
    sdk::gfx::RenderTargetBitmapSP& bitmap) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          CreateBitmapFromRawData(
    const SDKSize& bitmap_size, const SDKUInt32& source_data_stride_size,
    const sdk::gfx::PixelFormats& source_data_pixel_format, const SDKUInt8* source_data,
    sdk::gfx::RenderTargetBitmapSP& bitmap) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          CreateIndexBitmap(
    const SDKSize& bitmap_size, const SDKUInt32& source_data_stride_size,
    const sdk::gfx::PixelFormats& source_data_pixel_format, const SDKUInt8* source_data, 
    const SDKUInt8* source_palette_data, SDKUInt32 source_palette_data_size,
    sdk::gfx::RenderTargetBitmapSP& bitmap) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          CreateSolidColorBrush(const SDKColorF& clr, 
    sdk::gfx::RenderTargetBrushSP& brush) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          CreateBitmapBrush(
    const sdk::gfx::RenderTargetBitmapSP& bitmap, 
    const sdk::gfx::BitmapBrushExtendMode& ox_extend_mode,
    const sdk::gfx::BitmapBrushExtendMode& oy_extend_mode,
    sdk::gfx::RenderTargetBrushSP& brush) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          CreateStrokeStyle(
    const sdk::gfx::StrokeStyleOptions& style_options, 
    const float* line_dash_pattern, const SDKUInt32& line_dash_pattern_size,
    sdk::gfx::RenderTargetStrokeStyleSP& stroke_style) const throw() = 0;
  
  virtual SDKResult SDK_CALLTYPE          CreateText(const SDKString& output_text,
    const SDKString& font_family_name, const sdk::gfx::FontStyle& font_style,
    const sdk::gfx::FontWeight& font_weight, const float& font_size,
    sdk::gfx::RenderTargetTextSP& text) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          CalcStrokedBounds(
    const sdk::gfx::GraphicsPathSP& path, 
    const SDKMatrix3X2& transformation_matrix, const float& line_width, 
    const sdk::gfx::RenderTargetStrokeStyleSP& stroke_style,
    SDKRectF2D& bounds) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          GetTextPath(const SDKPointF2D& origin_point,
    const sdk::gfx::RenderTargetTextSP& text, 
    sdk::gfx::GraphicsPathSP& text_path) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          CalcTextBounds(const SDKPointF2D& origin_point,
    const sdk::gfx::RenderTargetTextSP& text, SDKRectF2D& bounds) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          GetTextFontMetrics(
    const sdk::gfx::RenderTargetTextSP& text,
    sdk::gfx::FontMetrics& text_font_metrics) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          StartDraw() throw() = 0;
  virtual SDKResult SDK_CALLTYPE          FinishDraw() throw() = 0;
  virtual SDKResult SDK_CALLTYPE          IsDrawInProgress(
    bool& is_draw_in_progress) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          FlushBuffers() throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          FillBackground(const SDKColorF& clr) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          FillPath(const sdk::gfx::GraphicsPathSP& path, 
    const sdk::gfx::RenderTargetBrushSP& brush) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          DrawPath(const sdk::gfx::GraphicsPathSP& path,
    const sdk::gfx::RenderTargetBrushSP& brush, const float& line_width,
    const sdk::gfx::RenderTargetStrokeStyleSP& stroke_style) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          WriteText(const SDKPointF2D& origin_point,
    const sdk::gfx::RenderTargetTextSP& text, 
    const sdk::gfx::RenderTargetBrushSP& brush) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          DrawBitmap(const RenderTargetBitmapSP& bitmap,
    const SDKRectF2D& source_bitmap_rect, const SDKRectF2D& dest_rect) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          PushTransformationMatrix(
    const SDKMatrix3X2& transformation_matrix) throw() = 0;
  virtual SDKResult SDK_CALLTYPE          PopTransformationMatrix() throw() = 0;
  virtual SDKResult SDK_CALLTYPE          GetTransformationMatrix(
    SDKMatrix3X2& transformation_matrix) const throw() = 0;
  virtual SDKResult SDK_CALLTYPE          RemoveTransformationMatrixes() throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE          PushClippingPath(
    const sdk::gfx::GraphicsPathSP& clip_path) throw() = 0;
  virtual SDKResult SDK_CALLTYPE          PopClippingPath() throw() = 0;
  virtual SDKResult SDK_CALLTYPE          RemoveClippingPathes() throw() = 0;
 
 
  SDK_IMPLEMENT_IID(I2DRenderTarget)
  SDK_END_INTERFACE(I2DRenderTarget)
};
SDK_DECLARE_IID(I2DRenderTarget)
 
class RTAutoStartFinishDraw
{
public:
  RTAutoStartFinishDraw(const RenderTargetSP& rt)
    : m_rt(rt), m_start_draw_res(kSDKResult_NotInitialized)
  {
    if (m_rt) {
      bool is_draw_in_progress = false;
      if (SDK_OK(m_rt->IsDrawInProgress(is_draw_in_progress))) {
        if (!is_draw_in_progress) {
          m_start_draw_res = m_rt->StartDraw();
        }
      }
    }
  }
 
  ~RTAutoStartFinishDraw()
  {
    FinishDraw();
  }
 
  inline bool IsDrawStarted() const throw() { 
    bool is_draw_in_progress = false;
    if (!m_rt || SDK_FAILED(m_rt->IsDrawInProgress(is_draw_in_progress)))
      return false;
    return is_draw_in_progress;
  }
 
  void FinishDraw()
  {
    if (m_rt && SDK_OK(m_start_draw_res)) {
      m_rt->FinishDraw();
      m_start_draw_res = kSDKResult_NotInitialized;
    }
  }
 
private:
  const RenderTargetSP m_rt;
  SDKResult            m_start_draw_res;
};
 
class RTAutoRestoreAntiAliasingState
{
public:
  RTAutoRestoreAntiAliasingState(const RenderTargetSP& rt, 
    const sdk::gfx::AntiAliasingMode& new_mode)
    : m_rt(rt), m_new_mode_applied(false), m_prev_mode(sdk::gfx::AntiAliasingMode_None)
  {
    do 
    {
      if (!m_rt)
        break;
      if (IsSDKResultError(m_rt->GetAntiAliasingMode(m_prev_mode)))
        break;
      if (IsSDKResultError(m_rt->SetAntiAliasingMode(new_mode)))
        break;
 
      m_new_mode_applied = true;
    } 
    while (false);
  }
 
  ~RTAutoRestoreAntiAliasingState()
  {
    if (m_rt && m_new_mode_applied)
      m_rt->SetAntiAliasingMode(m_prev_mode);
  }
 
  inline bool IsNewModeApplied() const throw() { return m_new_mode_applied; }
 
private:
  const RenderTargetSP        m_rt;
  bool                        m_new_mode_applied;
  sdk::gfx::AntiAliasingMode  m_prev_mode;
};
 
} // namespace gfx
} // namespace sdk 
 
#endif // SDK_2D_RENDER_TARGET_INTERFACE_H_