Added more GPU bindings

diff --git a/include/c/gr_context.h b/include/c/gr_context.h
index 390bf07..d73236a 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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<GrContext*>(p);
 }
 
-static inline gr_backendrendertargetdesc_t* ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc* p) {
-    return reinterpret_cast<gr_backendrendertargetdesc_t*>(p);
+static inline gr_backend_rendertarget_desc_t* ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc* p) {
+    return reinterpret_cast<gr_backend_rendertarget_desc_t*>(p);
 }
 
-static inline GrBackendRenderTargetDesc* AsGrBackendRenderTargetDesc(gr_backendrendertargetdesc_t* p) {
+static inline GrBackendRenderTargetDesc* AsGrBackendRenderTargetDesc(gr_backend_rendertarget_desc_t* p) {
     return reinterpret_cast<GrBackendRenderTargetDesc*>(p);
 }
 
-static inline gr_backendrendertargetdesc_t& ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc& p) {
-    return reinterpret_cast<gr_backendrendertargetdesc_t&>(p);
+static inline gr_backend_rendertarget_desc_t& ToGrBackendRenderTargetDesc(GrBackendRenderTargetDesc& p) {
+    return reinterpret_cast<gr_backend_rendertarget_desc_t&>(p);
 }
 
-static inline GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(gr_backendrendertargetdesc_t& p) {
+static inline GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(gr_backend_rendertarget_desc_t& p) {
     return reinterpret_cast<GrBackendRenderTargetDesc&>(p);
 }
 
-static inline const gr_backendrendertargetdesc_t* ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc* p) {
-    return reinterpret_cast<const gr_backendrendertargetdesc_t*>(p);
+static inline const gr_backend_rendertarget_desc_t* ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc* p) {
+    return reinterpret_cast<const gr_backend_rendertarget_desc_t*>(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<const GrBackendRenderTargetDesc*>(p);
 }
 
-static inline const gr_backendrendertargetdesc_t& ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc& p) {
-    return reinterpret_cast<const gr_backendrendertargetdesc_t&>(p);
+static inline const gr_backend_rendertarget_desc_t& ToGrBackendRenderTargetDesc(const GrBackendRenderTargetDesc& p) {
+    return reinterpret_cast<const gr_backend_rendertarget_desc_t&>(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<const GrBackendRenderTargetDesc&>(p);
 }
 
+static inline const GrBackendTextureDesc& AsGrBackendTextureDesc(const gr_backend_texture_desc_t& p) {
+    return reinterpret_cast<const GrBackendTextureDesc&>(p);
+}
+
+static inline gr_gl_interface_t* ToGrGLInterface(GrGLInterface* p) {
+    return reinterpret_cast<gr_gl_interface_t*>(p);
+}
+
+static inline GrGLInterface* AsGrGLInterface(gr_gl_interface_t* p) {
+    return reinterpret_cast<GrGLInterface*>(p);
+}
+
+static inline const gr_gl_interface_t* ToGrGLInterface(const GrGLInterface* p) {
+    return reinterpret_cast<const gr_gl_interface_t*>(p);
+}
+
+static inline const GrGLInterface* AsGrGLInterface(const gr_gl_interface_t* p) {
+    return reinterpret_cast<const GrGLInterface*>(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