From 36beec91fa5a36f8bfb8ac607f87124213a7e0bd Mon Sep 17 00:00:00 2001 From: Matthew Leibowitz Date: Wed, 17 Aug 2016 02:14:57 +0200 Subject: [PATCH] Added more GPU bindings --- include/c/gr_context.h | 4 ++++ include/c/sk_surface.h | 22 ++++++++++++++++++++- include/c/sk_types.h | 19 +++++++++++++++++- src/c/gr_context.cpp | 13 +++++++++++++ src/c/sk_enums.cpp | 40 +++++++++++++++++++++++++++++++++++++ src/c/sk_surface.cpp | 49 +++++++++++++++++++++++++++++++++++++++------- src/c/sk_types_priv.h | 53 +++++++++++++++++++++++++++++++++----------------- 7 files changed, 173 insertions(+), 27 deletions(-) diff --git a/include/c/gr_context.h b/include/c/gr_context.h index 390bf07..d73236a 100644 --- a/include/c/gr_context.h +++ b/include/c/gr_context.h @@ -18,6 +18,10 @@ SK_C_PLUS_PLUS_BEGIN_GUARD SK_API gr_context_t* gr_context_create_with_defaults(gr_backend_t backend, gr_backendcontext_t backendContext); SK_API void gr_context_unref(gr_context_t* context); +SK_API const gr_gl_interface_t* gr_gl_default_interface(); +SK_API const gr_gl_interface_t* gr_gl_create_native_interface(); +SK_API void gr_gl_interface_unref(gr_gl_interface_t* glInterface); + SK_C_PLUS_PLUS_END_GUARD #endif diff --git a/include/c/sk_surface.h b/include/c/sk_surface.h index 608b187..6d78ec1 100644 --- a/include/c/sk_surface.h +++ b/include/c/sk_surface.h @@ -76,7 +76,27 @@ SK_API sk_image_t* sk_surface_new_image_snapshot(sk_surface_t*); * ownership of the render target and the client must ensure the render target is valid for the * lifetime of the SkSurface. */ -SK_API sk_surface_t* sk_surface_new_backend_render_target(gr_context_t* context, const gr_backendrendertargetdesc_t* desc, const sk_surfaceprops_t* props); +SK_API sk_surface_t* sk_surface_new_backend_render_target(gr_context_t* context, const gr_backend_rendertarget_desc_t* desc, const sk_surfaceprops_t* props); + +/** + * Used to wrap a pre-existing backend 3D API texture as a SkSurface. The kRenderTarget flag + * must be set on GrBackendTextureDesc for this to succeed. Skia will not assume ownership + * of the texture and the client must ensure the texture is valid for the lifetime of the + * SkSurface. + */ +SK_API sk_surface_t* sk_surface_new_backend_texture(gr_context_t* context, const gr_backend_texture_desc_t* desc, const sk_surfaceprops_t* props); + +/** + * Used to wrap a pre-existing 3D API texture as a SkSurface. Skia will treat the texture as + * a rendering target only, but unlike NewFromBackendRenderTarget, Skia will manage and own + * the associated render target objects (but not the provided texture). The kRenderTarget flag + * must be set on GrBackendTextureDesc for this to succeed. Skia will not assume ownership + * of the texture and the client must ensure the texture is valid for the lifetime of the + * SkSurface. + */ +SK_API sk_surface_t* sk_surface_new_backend_texture_as_render_target(gr_context_t* context, const gr_backend_texture_desc_t* desc, const sk_surfaceprops_t* props); + +SK_API sk_surface_t* sk_surface_new_render_target(gr_context_t* context, bool budgeted, const sk_imageinfo_t* info, int sampleCount, const sk_surfaceprops_t* props); SK_C_PLUS_PLUS_END_GUARD diff --git a/include/c/sk_types.h b/include/c/sk_types.h index 17166b6..7c4303c 100644 --- a/include/c/sk_types.h +++ b/include/c/sk_types.h @@ -548,7 +548,22 @@ typedef struct { int fSampleCnt; int fStencilBits; gr_backendobject_t fRenderTargetHandle; -} gr_backendrendertargetdesc_t; +} gr_backend_rendertarget_desc_t; + +typedef enum { + NONE_GR_BACKEND_TEXTURE_FLAGS = 0, + RENDER_TARGET_GR_BACKEND_TEXTURE_FLAGS = 1, +} gr_backendtexture_flags_t; + +typedef struct { + gr_backendtexture_flags_t fFlags; + gr_surfaceorigin_t fOrigin; + int fWidth; + int fHeight; + gr_pixelconfig_t fConfig; + int fSampleCnt; + gr_backendobject_t fTextureHandle; +} gr_backend_texture_desc_t; typedef struct gr_context_t gr_context_t; @@ -559,6 +574,8 @@ typedef enum { typedef intptr_t gr_backendcontext_t; +typedef struct gr_gl_interface_t gr_gl_interface_t; + SK_C_PLUS_PLUS_END_GUARD #endif diff --git a/src/c/gr_context.cpp b/src/c/gr_context.cpp index 5790400..df43475 100644 --- a/src/c/gr_context.cpp +++ b/src/c/gr_context.cpp @@ -6,6 +6,7 @@ */ #include "GrContext.h" +#include "gl/GrGLInterface.h" #include "gr_context.h" @@ -18,3 +19,15 @@ gr_context_t* gr_context_create_with_defaults(gr_backend_t backend, gr_backendco void gr_context_unref(gr_context_t* context) { AsGrContext(context)->unref(); } + +const gr_gl_interface_t* gr_gl_default_interface() { + return ToGrGLInterface(GrGLDefaultInterface()); +} + +const gr_gl_interface_t* gr_gl_create_native_interface() { + return ToGrGLInterface(GrGLCreateNativeInterface()); +} + +void gr_gl_interface_unref(gr_gl_interface_t* glInterface) { + AsGrGLInterface(glInterface)->unref(); +} \ No newline at end of file diff --git a/src/c/sk_enums.cpp b/src/c/sk_enums.cpp index 8987ff4..2c42e2b 100644 --- a/src/c/sk_enums.cpp +++ b/src/c/sk_enums.cpp @@ -242,4 +242,44 @@ static_assert ((int)SkCanvas::PointMode::kPoints_PointMode == (int)POINTS_SK_ static_assert ((int)SkCanvas::PointMode::kLines_PointMode == (int)LINES_SK_POINT_MODE, ASSERT_MSG(SkCanvas::PointMode, sk_point_mode_t)); static_assert ((int)SkCanvas::PointMode::kPolygon_PointMode == (int)POLYGON_SK_POINT_MODE, ASSERT_MSG(SkCanvas::PointMode, sk_point_mode_t)); +// sk_surfaceprops_flags_t +static_assert ((int)SkSurfaceProps::Flags::kDisallowAntiAlias_Flag == (int)DISALLOW_ANTIALIAS_GR_SURFACE_PROPS_FLAGS, ASSERT_MSG(SkSurfaceProps::Flags, sk_surfaceprops_flags_t)); +static_assert ((int)SkSurfaceProps::Flags::kDisallowDither_Flag == (int)DISALLOW_DITHER_GR_SURFACE_PROPS_FLAGS, ASSERT_MSG(SkSurfaceProps::Flags, sk_surfaceprops_flags_t)); +static_assert ((int)SkSurfaceProps::Flags::kGammaCorrect_Flag == (int)GAMMA_CORRECT_GR_SURFACE_PROPS_FLAGS, ASSERT_MSG(SkSurfaceProps::Flags, sk_surfaceprops_flags_t)); +static_assert ((int)SkSurfaceProps::Flags::kUseDeviceIndependentFonts_Flag == (int)USE_DEVICE_INDEPENDENT_FONTS_GR_SURFACE_PROPS_FLAGS, ASSERT_MSG(SkSurfaceProps::Flags, sk_surfaceprops_flags_t)); + +// gr_surfaceorigin_t +static_assert ((int)GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin == (int)BOTTOM_LEFT_GR_SURFACE_ORIGIN, ASSERT_MSG(GrSurfaceOrigin, gr_surfaceorigin_t)); +static_assert ((int)GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin == (int)TOP_LEFT_GR_SURFACE_ORIGIN, ASSERT_MSG(GrSurfaceOrigin, gr_surfaceorigin_t)); + +// gr_pixelconfig_t +static_assert ((int)GrPixelConfig::kUnknown_GrPixelConfig == (int)UNKNOWN_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kAlpha_8_GrPixelConfig == (int)ALPHA_8_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kIndex_8_GrPixelConfig == (int)INDEX_8_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kRGB_565_GrPixelConfig == (int)RGB_565_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kRGBA_4444_GrPixelConfig == (int)RGBA_4444_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kRGBA_8888_GrPixelConfig == (int)RGBA_8888_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kBGRA_8888_GrPixelConfig == (int)BGRA_8888_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kSRGBA_8888_GrPixelConfig == (int)SRGBA_8888_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kSBGRA_8888_GrPixelConfig == (int)SBGRA_8888_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kETC1_GrPixelConfig == (int)ETC1_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kLATC_GrPixelConfig == (int)LATC_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kR11_EAC_GrPixelConfig == (int)R11_EAC_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kASTC_12x12_GrPixelConfig == (int)ASTC_12X12_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kRGBA_float_GrPixelConfig == (int)RGBA_FLOAT_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kAlpha_half_GrPixelConfig == (int)ALPHA_HALF_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); +static_assert ((int)GrPixelConfig::kRGBA_half_GrPixelConfig == (int)RGBA_HALF_GR_PIXEL_CONFIG, ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t)); + +// gr_backendtexture_flags_t +static_assert ((int)GrBackendTextureFlags::kNone_GrBackendTextureFlag == (int)NONE_GR_BACKEND_TEXTURE_FLAGS, ASSERT_MSG(GrBackendTextureFlags, gr_backendtexture_flags_t)); +static_assert ((int)GrBackendTextureFlags::kRenderTarget_GrBackendTextureFlag == (int)RENDER_TARGET_GR_BACKEND_TEXTURE_FLAGS, ASSERT_MSG(GrBackendTextureFlags, gr_backendtexture_flags_t)); + +// gr_backend_t +static_assert ((int)GrBackend::kOpenGL_GrBackend == (int)OPENGL_GR_BACKEND, ASSERT_MSG(GrBackendTextureFlags, gr_backend_t)); +static_assert ((int)GrBackend::kVulkan_GrBackend == (int)VULKAN_GR_BACKEND, ASSERT_MSG(GrBackendTextureFlags, gr_backend_t)); + +// SkBudgeted +static_assert ((bool)SkBudgeted::kNo == (bool)false, ASSERT_MSG(SkBudgeted, bool)); +static_assert ((bool)SkBudgeted::kYes == (bool)true, ASSERT_MSG(SkBudgeted, bool)); + #endif diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp index 04bd755..71cfc53 100644 --- a/src/c/sk_surface.cpp +++ b/src/c/sk_surface.cpp @@ -32,15 +32,21 @@ sk_colortype_t sk_colortype_get_default_8888() { sk_surface_t* sk_surface_new_raster(const sk_imageinfo_t* cinfo, const sk_surfaceprops_t* props) { SkImageInfo info; from_c(*cinfo, &info); - SkSurfaceProps surfProps = AsSurfaceProps(props); - return ToSurface(SkSurface::MakeRaster(info, &surfProps).release()); + SkSurfaceProps* surfProps = nullptr; + if (props) { + from_c(props, surfProps); + } + return ToSurface(SkSurface::MakeRaster(info, surfProps).release()); } sk_surface_t* sk_surface_new_raster_direct(const sk_imageinfo_t* cinfo, void* pixels, size_t rowBytes, const sk_surfaceprops_t* props) { SkImageInfo info; from_c(*cinfo, &info); - SkSurfaceProps surfProps = AsSurfaceProps(props); - return ToSurface(SkSurface::MakeRasterDirect(info, pixels, rowBytes, &surfProps).release()); + SkSurfaceProps* surfProps = nullptr; + if (props) { + from_c(props, surfProps); + } + return ToSurface(SkSurface::MakeRasterDirect(info, pixels, rowBytes, surfProps).release()); } void sk_surface_unref(sk_surface_t* csurf) { @@ -55,7 +61,36 @@ sk_image_t* sk_surface_new_image_snapshot(sk_surface_t* csurf) { return ToImage(AsSurface(csurf)->makeImageSnapshot().release()); } -sk_surface_t* sk_surface_new_backend_render_target(gr_context_t* context, const gr_backendrendertargetdesc_t* desc, const sk_surfaceprops_t* props) { - const SkSurfaceProps surfProps = (const SkSurfaceProps)AsSurfaceProps(props); - return ToSurface(SkSurface::MakeFromBackendRenderTarget(AsGrContext(context), AsGrBackendRenderTargetDesc(*desc), &surfProps).release()); +sk_surface_t* sk_surface_new_backend_render_target(gr_context_t* context, const gr_backend_rendertarget_desc_t* desc, const sk_surfaceprops_t* props) { + SkSurfaceProps* surfProps = nullptr; + if (props) { + from_c(props, surfProps); + } + return ToSurface(SkSurface::MakeFromBackendRenderTarget(AsGrContext(context), AsGrBackendRenderTargetDesc(*desc), surfProps).release()); +} + +sk_surface_t* sk_surface_new_backend_texture(gr_context_t* context, const gr_backend_texture_desc_t* desc, const sk_surfaceprops_t* props) { + SkSurfaceProps* surfProps = nullptr; + if (props) { + from_c(props, surfProps); + } + return ToSurface(SkSurface::MakeFromBackendTexture(AsGrContext(context), AsGrBackendTextureDesc(*desc), surfProps).release()); +} + +sk_surface_t* sk_surface_new_backend_texture_as_render_target(gr_context_t* context, const gr_backend_texture_desc_t* desc, const sk_surfaceprops_t* props) { + SkSurfaceProps* surfProps = nullptr; + if (props) { + from_c(props, surfProps); + } + return ToSurface(SkSurface::MakeFromBackendTextureAsRenderTarget(AsGrContext(context), AsGrBackendTextureDesc(*desc), surfProps).release()); +} + +sk_surface_t* sk_surface_new_render_target(gr_context_t* context, bool budgeted, const sk_imageinfo_t* cinfo, int sampleCount, const sk_surfaceprops_t* props) { + SkImageInfo info; + from_c(*cinfo, &info); + SkSurfaceProps* surfProps = nullptr; + if (props) { + from_c(props, surfProps); + } + return ToSurface(SkSurface::MakeRenderTarget(AsGrContext(context), (SkBudgeted)budgeted, info, sampleCount, surfProps).release()); } diff --git a/src/c/sk_types_priv.h b/src/c/sk_types_priv.h index 51bf280..a40ef62 100644 --- a/src/c/sk_types_priv.h +++ b/src/c/sk_types_priv.h @@ -24,6 +24,7 @@ #include "SkMatrixConvolutionImageFilter.h" #include "Sk1DPathEffect.h" #include "SkFontStyle.h" +#include "gl/GrGLInterface.h" #include "sk_path.h" #include "sk_paint.h" @@ -452,38 +453,58 @@ static inline GrContext* AsGrContext(gr_context_t* p) { return reinterpret_cast(p); } -static inline gr_backendrendertargetdesc_t* ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc* p) { - return reinterpret_cast(p); +static inline gr_backend_rendertarget_desc_t* ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc* p) { + return reinterpret_cast(p); } -static inline GrBackendRenderTargetDesc* AsGrBackendRenderTargetDesc(gr_backendrendertargetdesc_t* p) { +static inline GrBackendRenderTargetDesc* AsGrBackendRenderTargetDesc(gr_backend_rendertarget_desc_t* p) { return reinterpret_cast(p); } -static inline gr_backendrendertargetdesc_t& ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc& p) { - return reinterpret_cast(p); +static inline gr_backend_rendertarget_desc_t& ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc& p) { + return reinterpret_cast(p); } -static inline GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(gr_backendrendertargetdesc_t& p) { +static inline GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(gr_backend_rendertarget_desc_t& p) { return reinterpret_cast(p); } -static inline const gr_backendrendertargetdesc_t* ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc* p) { - return reinterpret_cast(p); +static inline const gr_backend_rendertarget_desc_t* ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc* p) { + return reinterpret_cast(p); } -static inline const GrBackendRenderTargetDesc* AsGrBackendRenderTargetDesc(const gr_backendrendertargetdesc_t* p) { +static inline const GrBackendRenderTargetDesc* AsGrBackendRenderTargetDesc(const gr_backend_rendertarget_desc_t* p) { return reinterpret_cast(p); } -static inline const gr_backendrendertargetdesc_t& ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc& p) { - return reinterpret_cast(p); +static inline const gr_backend_rendertarget_desc_t& ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc& p) { + return reinterpret_cast(p); } -static inline const GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(const gr_backendrendertargetdesc_t& p) { +static inline const GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(const gr_backend_rendertarget_desc_t& p) { return reinterpret_cast(p); } +static inline const GrBackendTextureDesc& AsGrBackendTextureDesc(const gr_backend_texture_desc_t& p) { + return reinterpret_cast(p); +} + +static inline gr_gl_interface_t* ToGrGLInterface(GrGLInterface* p) { + return reinterpret_cast(p); +} + +static inline GrGLInterface* AsGrGLInterface(gr_gl_interface_t* p) { + return reinterpret_cast(p); +} + +static inline const gr_gl_interface_t* ToGrGLInterface(const GrGLInterface* p) { + return reinterpret_cast(p); +} + +static inline const GrGLInterface* AsGrGLInterface(const gr_gl_interface_t* p) { + return reinterpret_cast(p); +} + static inline void from_c(const sk_matrix_t* cmatrix, SkMatrix* matrix) { matrix->setAll( cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2], @@ -529,12 +550,8 @@ static inline bool from_sk(const SkImageInfo& info, sk_imageinfo_t* cinfo) { return true; } -static inline SkSurfaceProps AsSurfaceProps(const sk_surfaceprops_t* cprops) { - if (cprops) { - return SkSurfaceProps(cprops->flags, (SkPixelGeometry)cprops->pixelGeometry); - } else { - return SkSurfaceProps(0, SkPixelGeometry::kUnknown_SkPixelGeometry); - } +static inline void from_c(const sk_surfaceprops_t* cprops, SkSurfaceProps* props) { + *props = SkSurfaceProps(cprops->flags, (SkPixelGeometry)cprops->pixelGeometry); } #endif -- 2.7.4