├── index.js ├── .gitignore ├── libs ├── win32 │ ├── libSkiaSharp.dll │ └── libSkiaSharp.lib ├── darwin │ └── libSkiaSharp.dylib └── linux │ └── libSkiaSharp.so.68.2.0 ├── include └── c │ ├── sk_svg.h │ ├── sk_xml.h │ ├── sk_string.h │ ├── sk_colortable.h │ ├── sk_vertices.h │ ├── sk_drawable.h │ ├── sk_maskfilter.h │ ├── sk_general.h │ ├── sk_mask.h │ ├── sk_document.h │ ├── sk_picture.h │ ├── sk_data.h │ ├── sk_colorfilter.h │ ├── sk_region.h │ ├── sk_patheffect.h │ ├── sk_textblob.h │ ├── sk_rrect.h │ ├── sk_codec.h │ ├── sk_surface.h │ ├── sk_pixmap.h │ ├── sk_colorspace.h │ ├── sk_bitmap.h │ ├── sk_image.h │ ├── gr_context.h │ ├── sk_shader.h │ ├── sk_typeface.h │ ├── sk_matrix.h │ ├── sk_stream.h │ ├── sk_paint.h │ ├── sk_imagefilter.h │ ├── sk_canvas.h │ ├── sk_path.h │ └── sk_types.h ├── package.json ├── binding.gyp ├── LICENSE ├── README.md ├── examples ├── rain.js ├── index.js └── part.js └── generated └── index.c /index.js: -------------------------------------------------------------------------------- 1 | module.exports = require(`./generated/interface`); 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | .DS_Store 3 | templates 4 | generator 5 | -------------------------------------------------------------------------------- /libs/win32/libSkiaSharp.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Reon90/skiaJS/HEAD/libs/win32/libSkiaSharp.dll -------------------------------------------------------------------------------- /libs/win32/libSkiaSharp.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Reon90/skiaJS/HEAD/libs/win32/libSkiaSharp.lib -------------------------------------------------------------------------------- /libs/darwin/libSkiaSharp.dylib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Reon90/skiaJS/HEAD/libs/darwin/libSkiaSharp.dylib -------------------------------------------------------------------------------- /libs/linux/libSkiaSharp.so.68.2.0: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Reon90/skiaJS/HEAD/libs/linux/libSkiaSharp.so.68.2.0 -------------------------------------------------------------------------------- /include/c/sk_svg.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_svg_DEFINED 11 | #define sk_svg_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_canvas_t* sk_svgcanvas_create(const sk_rect_t* bounds, sk_xmlwriter_t* writer); 18 | 19 | SK_C_PLUS_PLUS_END_GUARD 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /include/c/sk_xml.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_xml_DEFINED 11 | #define sk_xml_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_xmlstreamwriter_t* sk_xmlstreamwriter_new(sk_wstream_t* stream); 18 | SK_C_API void sk_xmlstreamwriter_delete(sk_xmlstreamwriter_t* writer); 19 | 20 | SK_C_PLUS_PLUS_END_GUARD 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /include/c/sk_string.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_string_DEFINED 11 | #define sk_string_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_string_t* sk_string_new_empty(void); 18 | SK_C_API sk_string_t* sk_string_new_with_copy(const char* src, size_t length); 19 | SK_C_API void sk_string_destructor(const sk_string_t*); 20 | SK_C_API size_t sk_string_get_size(const sk_string_t*); 21 | SK_C_API const char* sk_string_get_c_str(const sk_string_t*); 22 | 23 | SK_C_PLUS_PLUS_END_GUARD 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /include/c/sk_colortable.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_colortable_DEFINED 11 | #define sk_colortable_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_colortable_unref(sk_colortable_t* ctable); 18 | SK_C_API sk_colortable_t* sk_colortable_new(const sk_pmcolor_t* colors, int count); 19 | SK_C_API int sk_colortable_count(const sk_colortable_t* ctable); 20 | SK_C_API void sk_colortable_read_colors(const sk_colortable_t* ctable, sk_pmcolor_t** colors); 21 | 22 | SK_C_PLUS_PLUS_END_GUARD 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /include/c/sk_vertices.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_vertices_DEFINED 11 | #define sk_vertices_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_vertices_unref(sk_vertices_t* cvertices); 18 | SK_C_API void sk_vertices_ref(sk_vertices_t* cvertices); 19 | SK_C_API sk_vertices_t* sk_vertices_make_copy(sk_vertices_vertex_mode_t vmode, int vertexCount, const sk_point_t* positions, const sk_point_t* texs, const sk_color_t* colors, int indexCount, const uint16_t* indices); 20 | 21 | SK_C_PLUS_PLUS_END_GUARD 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /include/c/sk_drawable.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2015 Xamarin Inc. 3 | * Copyright 2017 Microsoft Corporation. All rights reserved. 4 | * 5 | * Use of this source code is governed by a BSD-style license that can be 6 | * found in the LICENSE file. 7 | */ 8 | 9 | #ifndef sk_drawable_DEFINED 10 | #define sk_drawable_DEFINED 11 | 12 | #include "sk_types.h" 13 | 14 | SK_C_PLUS_PLUS_BEGIN_GUARD 15 | 16 | typedef struct sk_drawable_t sk_drawable_t; 17 | 18 | SK_C_API void sk_drawable_unref (sk_drawable_t*); 19 | SK_C_API uint32_t sk_drawable_get_generation_id (sk_drawable_t*); 20 | SK_C_API void sk_drawable_get_bounds (sk_drawable_t*, sk_rect_t*); 21 | SK_C_API void sk_drawable_draw (sk_drawable_t*, sk_canvas_t*, const sk_matrix_t*); 22 | SK_C_API sk_picture_t* sk_drawable_new_picture_snapshot(sk_drawable_t*); 23 | SK_C_API void sk_drawable_notify_drawing_changed (sk_drawable_t*); 24 | 25 | SK_C_PLUS_PLUS_END_GUARD 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "skia-n-api", 3 | "version": "0.0.4", 4 | "description": "The N-API bindings for Skia Graphics Library", 5 | "main": "index.js", 6 | "devDependencies": { 7 | "node-gyp": "^3.8.0", 8 | "nunjucks": "^3.2.0", 9 | "xml-js": "^1.6.11", 10 | "glfw-n-api": "^0.0.4" 11 | }, 12 | "repository": { 13 | "type": "git", 14 | "url": "https://github.com/Reon90/skiaJS.git" 15 | }, 16 | "keywords": [ 17 | "skia", 18 | "N-API", 19 | "bindings", 20 | "opengl", 21 | "vulkan", 22 | "graphics library" 23 | ], 24 | "author": "Artem Kunets", 25 | "license": "MIT", 26 | "bugs": { 27 | "url": "https://github.com/Reon90/skiaJS/issues" 28 | }, 29 | "scripts": { 30 | "run": "node examples/index.js", 31 | "build": "node-gyp build" 32 | }, 33 | "gypfile": false 34 | } 35 | 36 | -------------------------------------------------------------------------------- /include/c/sk_maskfilter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_maskfilter_DEFINED 11 | #define sk_maskfilter_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_maskfilter_ref(sk_maskfilter_t*); 18 | SK_C_API void sk_maskfilter_unref(sk_maskfilter_t*); 19 | SK_C_API sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t, float sigma); 20 | SK_C_API sk_maskfilter_t* sk_maskfilter_new_blur_with_flags(sk_blurstyle_t, float sigma, const sk_rect_t* occluder, bool respectCTM); 21 | SK_C_API sk_maskfilter_t* sk_maskfilter_new_table(const uint8_t table[256]); 22 | SK_C_API sk_maskfilter_t* sk_maskfilter_new_gamma(float gamma); 23 | SK_C_API sk_maskfilter_t* sk_maskfilter_new_clip(uint8_t min, uint8_t max); 24 | 25 | SK_C_PLUS_PLUS_END_GUARD 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /include/c/sk_general.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2019 Microsoft Corporation. All rights reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license that can be 5 | * found in the LICENSE file. 6 | */ 7 | 8 | #ifndef sk_general_DEFINED 9 | #define sk_general_DEFINED 10 | 11 | #include "sk_types.h" 12 | 13 | SK_C_PLUS_PLUS_BEGIN_GUARD 14 | 15 | // ref counting 16 | 17 | SK_C_API bool sk_refcnt_unique(const sk_refcnt_t* refcnt); 18 | SK_C_API int sk_refcnt_get_ref_count(const sk_refcnt_t* refcnt); 19 | SK_C_API void sk_refcnt_safe_ref(sk_refcnt_t* refcnt); 20 | SK_C_API void sk_refcnt_safe_unref(sk_refcnt_t* refcnt); 21 | 22 | SK_C_API bool sk_nvrefcnt_unique(const sk_nvrefcnt_t* refcnt); 23 | SK_C_API int sk_nvrefcnt_get_ref_count(const sk_nvrefcnt_t* refcnt); 24 | SK_C_API void sk_nvrefcnt_safe_ref(sk_nvrefcnt_t* refcnt); 25 | SK_C_API void sk_nvrefcnt_safe_unref(sk_nvrefcnt_t* refcnt); 26 | 27 | // color type 28 | 29 | SK_C_API sk_colortype_t sk_colortype_get_default_8888(void); 30 | 31 | SK_C_PLUS_PLUS_END_GUARD 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /binding.gyp: -------------------------------------------------------------------------------- 1 | { 2 | "variables": { 3 | "skia": "<@(module_root_dir)/libs" 4 | }, 5 | "targets": [ 6 | { 7 | "target_name": "skiaJS", 8 | "sources": [ "generated/index.c" ], 9 | "include_dirs": [ 10 | "<@(module_root_dir)", 11 | ], 12 | "conditions": [ 13 | [ 14 | "OS=='linux'", 15 | { 16 | "libraries": [ 17 | "-Wl,-rpath=\'$${ORIGIN}/../../../libs/linux'", 18 | "<(skia)/linux/libSkiaSharp.so" 19 | ] 20 | } 21 | ], 22 | [ 23 | "OS=='win'", 24 | { 25 | "libraries": [ 26 | "<(skia)/win32/libSkiaSharp.lib", 27 | ] 28 | } 29 | ], 30 | [ 31 | "OS=='mac'", 32 | { 33 | "xcode_settings": { 34 | "OTHER_LDFLAGS": [ 35 | "<(skia)/darwin/libSkiaSharp.dylib", 36 | "-Wl,-rpath -Wl,@loader_path/../../../libs/darwin" 37 | ] 38 | } 39 | } 40 | ] 41 | ] 42 | } 43 | ] 44 | } 45 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2020 Artem Kunets 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /include/c/sk_mask.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Bluebeam Inc. 5 | * Copyright 2017 Microsoft Corporation. All rights reserved. 6 | * 7 | * Use of this source code is governed by a BSD-style license that can be 8 | * found in the LICENSE file. 9 | */ 10 | 11 | #ifndef sk_mask_DEFINED 12 | #define sk_mask_DEFINED 13 | 14 | #include "sk_types.h" 15 | 16 | SK_C_PLUS_PLUS_BEGIN_GUARD 17 | 18 | SK_C_API uint8_t* sk_mask_alloc_image(size_t bytes); 19 | SK_C_API void sk_mask_free_image(void* image); 20 | SK_C_API bool sk_mask_is_empty(sk_mask_t* cmask); 21 | SK_C_API size_t sk_mask_compute_image_size(sk_mask_t* cmask); 22 | SK_C_API size_t sk_mask_compute_total_image_size(sk_mask_t* cmask); 23 | SK_C_API uint8_t sk_mask_get_addr_1(sk_mask_t* cmask, int x, int y); 24 | SK_C_API uint8_t sk_mask_get_addr_8(sk_mask_t* cmask, int x, int y); 25 | SK_C_API uint16_t sk_mask_get_addr_lcd_16(sk_mask_t* cmask, int x, int y); 26 | SK_C_API uint32_t sk_mask_get_addr_32(sk_mask_t* cmask, int x, int y); 27 | SK_C_API void* sk_mask_get_addr(sk_mask_t* cmask, int x, int y); 28 | 29 | SK_C_PLUS_PLUS_END_GUARD 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/c/sk_document.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_document_DEFINED 11 | #define sk_document_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_document_unref(sk_document_t* document); 18 | 19 | SK_C_API sk_document_t* sk_document_create_pdf_from_stream(sk_wstream_t* stream); 20 | SK_C_API sk_document_t* sk_document_create_pdf_from_stream_with_metadata(sk_wstream_t* stream, const sk_document_pdf_metadata_t* metadata); 21 | 22 | SK_C_API sk_document_t* sk_document_create_xps_from_stream(sk_wstream_t* stream, float dpi); 23 | 24 | SK_C_API sk_canvas_t* sk_document_begin_page(sk_document_t* document, float width, float height, const sk_rect_t* content); 25 | SK_C_API void sk_document_end_page(sk_document_t* document); 26 | SK_C_API void sk_document_close(sk_document_t* document); 27 | SK_C_API void sk_document_abort(sk_document_t* document); 28 | 29 | SK_C_PLUS_PLUS_END_GUARD 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/c/sk_picture.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_picture_DEFINED 11 | #define sk_picture_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_picture_recorder_t* sk_picture_recorder_new(void); 18 | SK_C_API void sk_picture_recorder_delete(sk_picture_recorder_t*); 19 | SK_C_API sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t*, const sk_rect_t*); 20 | SK_C_API sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t*); 21 | SK_C_API sk_drawable_t* sk_picture_recorder_end_recording_as_drawable(sk_picture_recorder_t*); 22 | SK_C_API sk_canvas_t* sk_picture_get_recording_canvas(sk_picture_recorder_t* crec); 23 | 24 | SK_C_API void sk_picture_ref(sk_picture_t*); 25 | SK_C_API void sk_picture_unref(sk_picture_t*); 26 | SK_C_API uint32_t sk_picture_get_unique_id(sk_picture_t*); 27 | SK_C_API void sk_picture_get_cull_rect(sk_picture_t*, sk_rect_t*); 28 | 29 | SK_C_PLUS_PLUS_END_GUARD 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/c/sk_data.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_data_DEFINED 11 | #define sk_data_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_data_t* sk_data_new_empty(void); 18 | SK_C_API sk_data_t* sk_data_new_with_copy(const void* src, size_t length); 19 | SK_C_API sk_data_t* sk_data_new_subset(const sk_data_t* src, size_t offset, size_t length); 20 | SK_C_API void sk_data_ref(const sk_data_t*); 21 | SK_C_API void sk_data_unref(const sk_data_t*); 22 | SK_C_API size_t sk_data_get_size(const sk_data_t*); 23 | SK_C_API const void* sk_data_get_data(const sk_data_t*); 24 | SK_C_API sk_data_t* sk_data_new_from_file(const char* path); 25 | SK_C_API sk_data_t* sk_data_new_from_stream(sk_stream_t* stream, size_t length); 26 | SK_C_API const uint8_t* sk_data_get_bytes(const sk_data_t*); 27 | SK_C_API sk_data_t* sk_data_new_with_proc(const void* ptr, size_t length, sk_data_release_proc proc, void* ctx); 28 | SK_C_API sk_data_t* sk_data_new_uninitialized(size_t size); 29 | 30 | SK_C_PLUS_PLUS_END_GUARD 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /include/c/sk_colorfilter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_colorfilter_DEFINED 11 | #define sk_colorfilter_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_colorfilter_unref(sk_colorfilter_t* filter); 18 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_mode(sk_color_t c, sk_blendmode_t mode); 19 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_lighting(sk_color_t mul, sk_color_t add); 20 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_compose(sk_colorfilter_t* outer, sk_colorfilter_t* inner); 21 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_color_matrix(const float array[20]); 22 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_luma_color(void); 23 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_high_contrast(const sk_highcontrastconfig_t* config); 24 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_table(const uint8_t table[256]); 25 | SK_C_API sk_colorfilter_t* sk_colorfilter_new_table_argb(const uint8_t tableA[256], const uint8_t tableR[256], const uint8_t tableG[256], const uint8_t tableB[256]); 26 | 27 | SK_C_PLUS_PLUS_END_GUARD 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /include/c/sk_region.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2016 Bluebeam Inc. 5 | * Copyright 2017 Microsoft Corporation. All rights reserved. 6 | * 7 | * Use of this source code is governed by a BSD-style license that can be 8 | * found in the LICENSE file. 9 | */ 10 | 11 | #ifndef sk_region_DEFINED 12 | #define sk_region_DEFINED 13 | 14 | #include "sk_types.h" 15 | 16 | SK_C_PLUS_PLUS_BEGIN_GUARD 17 | 18 | SK_C_API sk_region_t* sk_region_new(void); 19 | SK_C_API sk_region_t* sk_region_new2(const sk_region_t* region); 20 | SK_C_API void sk_region_delete(sk_region_t* cpath); 21 | SK_C_API bool sk_region_contains(sk_region_t* r, const sk_region_t* region); 22 | SK_C_API bool sk_region_contains2(sk_region_t* r, int x, int y); 23 | SK_C_API bool sk_region_intersects_rect(sk_region_t* r, const sk_irect_t* rect); 24 | SK_C_API bool sk_region_intersects(sk_region_t* r, const sk_region_t* src); 25 | SK_C_API bool sk_region_set_path(sk_region_t* dst, const sk_path_t* t, const sk_region_t* clip); 26 | SK_C_API bool sk_region_set_rect(sk_region_t* dst, const sk_irect_t* rect); 27 | SK_C_API bool sk_region_set_region(sk_region_t* r, const sk_region_t* region); 28 | SK_C_API bool sk_region_op(sk_region_t* dst, int left, int top, int right, int bottom, sk_region_op_t op); 29 | SK_C_API bool sk_region_op2(sk_region_t* dst, sk_region_t* src, sk_region_op_t op); 30 | SK_C_API void sk_region_get_bounds(sk_region_t* r, sk_irect_t* rect); 31 | 32 | SK_C_PLUS_PLUS_END_GUARD 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /include/c/sk_patheffect.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_patheffect_DEFINED 11 | #define sk_patheffect_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_path_effect_unref(sk_path_effect_t* t); 18 | SK_C_API sk_path_effect_t* sk_path_effect_create_compose(sk_path_effect_t* outer, sk_path_effect_t* inner); 19 | SK_C_API sk_path_effect_t* sk_path_effect_create_sum(sk_path_effect_t* first, sk_path_effect_t* second); 20 | SK_C_API sk_path_effect_t* sk_path_effect_create_discrete(float segLength, float deviation, uint32_t seedAssist /*0*/); 21 | SK_C_API sk_path_effect_t* sk_path_effect_create_corner(float radius); 22 | SK_C_API sk_path_effect_t* sk_path_effect_create_1d_path(const sk_path_t* path, float advance, float phase, sk_path_effect_1d_style_t style); 23 | SK_C_API sk_path_effect_t* sk_path_effect_create_2d_line(float width, const sk_matrix_t* matrix); 24 | SK_C_API sk_path_effect_t* sk_path_effect_create_2d_path(const sk_matrix_t* matrix, const sk_path_t* path); 25 | SK_C_API sk_path_effect_t* sk_path_effect_create_dash(const float intervals[], int count, float phase); 26 | SK_C_API sk_path_effect_t* sk_path_effect_create_trim(float start, float stop, sk_path_effect_trim_mode_t mode); 27 | 28 | SK_C_PLUS_PLUS_END_GUARD 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # skiaJS 2 | 3 | The N-API bindings for [Skia Graphics Library](https://skia.org/) 2D graphics library which provides common APIs that work across a variety of hardware and software platforms. It serves as the graphics engine for Google Chrome and Chrome OS, Android, Mozilla Firefox and Firefox OS, and many other products. 4 | 5 | ## Platforms 6 | Mac OS, Linux, Windows 7 | 8 | ## Example 9 | ```js 10 | // Rect 11 | const fill = skPaintNew(); 12 | skPaintSetColor(fill, skColorSetArgb(0xFF, 0xFF, 0x00, 0xFF)); 13 | const rect = new skRect({ 14 | left: 100, 15 | top: 100, 16 | right: 200, 17 | bottom: 200 18 | }); 19 | skCanvasDrawRect(canvas, rect, fill); 20 | 21 | // Text 22 | const familyName = "Times New Roman"; 23 | const style = skFontstyleNew(400, 1, enums.UPRIGHT_SK_FONT_STYLE_SLANT); 24 | const typeface = skTypefaceCreateFromNameWithFontStyle(familyName, style); 25 | const text = skPaintNew(); 26 | skPaintSetColor(text, skColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 27 | skPaintSetTextsize(text, 50.0); 28 | skPaintSetTypeface(text, typeface); 29 | const str = "skiaJS"; 30 | skCanvasDrawText(canvas, str, str.length, 100, 100, text); 31 | 32 | // Svg Path 33 | const stroke = skPaintNew(); 34 | skPaintSetColor(stroke, skColorSetArgb(0xFF, 0x00, 0x00, 0xFF)); 35 | skPaintSetAntialias(stroke, true); 36 | skPaintSetStyle(stroke, enums.STROKE_SK_PAINT_STYLE); 37 | skPaintSetStrokeWidth(stroke, 5.0); 38 | const path = skPathNew(); 39 | const svg = "m451.111 451.111h-451.111v-451.111h451.111zm-386.667-64.444h322.222v-322.223h-322.222z"; 40 | skPathParseSvgString(path, svg); 41 | skCanvasDrawPath(canvas, path, stroke); 42 | ``` 43 | -------------------------------------------------------------------------------- /include/c/sk_textblob.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_textblob_DEFINED 11 | #define sk_textblob_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_textblob_ref(const sk_textblob_t* blob); 18 | SK_C_API void sk_textblob_unref(const sk_textblob_t* blob); 19 | SK_C_API uint32_t sk_textblob_get_unique_id(const sk_textblob_t* blob); 20 | SK_C_API void sk_textblob_get_bounds(const sk_textblob_t* blob, sk_rect_t* bounds); 21 | 22 | SK_C_API sk_textblob_builder_t* sk_textblob_builder_new(); 23 | SK_C_API void sk_textblob_builder_delete(sk_textblob_builder_t* builder); 24 | SK_C_API sk_textblob_t* sk_textblob_builder_make(sk_textblob_builder_t* builder); 25 | SK_C_API void sk_textblob_builder_alloc_run_text(sk_textblob_builder_t* builder, const sk_paint_t* font, int count, float x, float y, int textByteCount, const sk_string_t* lang, const sk_rect_t* bounds, sk_textblob_builder_runbuffer_t* runbuffer); 26 | SK_C_API void sk_textblob_builder_alloc_run_text_pos_h(sk_textblob_builder_t* builder, const sk_paint_t* font, int count, float y, int textByteCount, const sk_string_t* lang, const sk_rect_t* bounds, sk_textblob_builder_runbuffer_t* runbuffer); 27 | SK_C_API void sk_textblob_builder_alloc_run_text_pos(sk_textblob_builder_t* builder, const sk_paint_t* font, int count, int textByteCount, const sk_string_t* lang, const sk_rect_t* bounds, sk_textblob_builder_runbuffer_t* runbuffer); 28 | 29 | SK_C_PLUS_PLUS_END_GUARD 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/c/sk_rrect.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2016 Xamarin Inc. 4 | * Copyright 2018 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_rrect_DEFINED 11 | #define sk_rrect_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_rrect_t* sk_rrect_new(void); 18 | SK_C_API sk_rrect_t* sk_rrect_new_copy(const sk_rrect_t* rrect); 19 | SK_C_API void sk_rrect_delete(const sk_rrect_t* rrect); 20 | SK_C_API sk_rrect_type_t sk_rrect_get_type(const sk_rrect_t* rrect); 21 | SK_C_API void sk_rrect_get_rect(const sk_rrect_t* rrect, sk_rect_t* rect); 22 | SK_C_API void sk_rrect_get_radii(const sk_rrect_t* rrect, sk_rrect_corner_t corner, sk_vector_t* radii); 23 | SK_C_API float sk_rrect_get_width(const sk_rrect_t* rrect); 24 | SK_C_API float sk_rrect_get_height(const sk_rrect_t* rrect); 25 | SK_C_API void sk_rrect_set_empty(sk_rrect_t* rrect); 26 | SK_C_API void sk_rrect_set_rect(sk_rrect_t* rrect, const sk_rect_t* rect); 27 | SK_C_API void sk_rrect_set_oval(sk_rrect_t* rrect, const sk_rect_t* rect); 28 | SK_C_API void sk_rrect_set_rect_xy(sk_rrect_t* rrect, const sk_rect_t* rect, float xRad, float yRad); 29 | SK_C_API void sk_rrect_set_nine_patch(sk_rrect_t* rrect, const sk_rect_t* rect, float leftRad, float topRad, float rightRad, float bottomRad); 30 | SK_C_API void sk_rrect_set_rect_radii(sk_rrect_t* rrect, const sk_rect_t* rect, const sk_vector_t* radii); 31 | SK_C_API void sk_rrect_inset(sk_rrect_t* rrect, float dx, float dy); 32 | SK_C_API void sk_rrect_outset(sk_rrect_t* rrect, float dx, float dy); 33 | SK_C_API void sk_rrect_offset(sk_rrect_t* rrect, float dx, float dy); 34 | SK_C_API bool sk_rrect_contains(const sk_rrect_t* rrect, const sk_rect_t* rect); 35 | SK_C_API bool sk_rrect_is_valid(const sk_rrect_t* rrect); 36 | SK_C_API bool sk_rrect_transform(sk_rrect_t* rrect, const sk_matrix_t* matrix, sk_rrect_t* dest); 37 | 38 | SK_C_PLUS_PLUS_END_GUARD 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /include/c/sk_codec.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_codec_DEFINED 11 | #define sk_codec_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API size_t sk_codec_min_buffered_bytes_needed(void); 18 | 19 | SK_C_API sk_codec_t* sk_codec_new_from_stream(sk_stream_t* stream, sk_codec_result_t* result); 20 | SK_C_API sk_codec_t* sk_codec_new_from_data(sk_data_t* data); 21 | SK_C_API void sk_codec_destroy(sk_codec_t* codec); 22 | SK_C_API void sk_codec_get_info(sk_codec_t* codec, sk_imageinfo_t* info); 23 | SK_C_API sk_encodedorigin_t sk_codec_get_origin(sk_codec_t* codec); 24 | SK_C_API void sk_codec_get_scaled_dimensions(sk_codec_t* codec, float desiredScale, sk_isize_t* dimensions); 25 | SK_C_API bool sk_codec_get_valid_subset(sk_codec_t* codec, sk_irect_t* desiredSubset); 26 | SK_C_API sk_encoded_image_format_t sk_codec_get_encoded_format(sk_codec_t* codec); 27 | SK_C_API sk_codec_result_t sk_codec_get_pixels(sk_codec_t* codec, const sk_imageinfo_t* info, void* pixels, size_t rowBytes, const sk_codec_options_t* options); 28 | SK_C_API sk_codec_result_t sk_codec_start_incremental_decode(sk_codec_t* codec, const sk_imageinfo_t* info, void* pixels, size_t rowBytes, const sk_codec_options_t* options); 29 | SK_C_API sk_codec_result_t sk_codec_incremental_decode(sk_codec_t* codec, int* rowsDecoded); 30 | SK_C_API sk_codec_result_t sk_codec_start_scanline_decode(sk_codec_t* codec, const sk_imageinfo_t* info, const sk_codec_options_t* options); 31 | SK_C_API int sk_codec_get_scanlines(sk_codec_t* codec, void* dst, int countLines, size_t rowBytes); 32 | SK_C_API bool sk_codec_skip_scanlines(sk_codec_t* codec, int countLines); 33 | SK_C_API sk_codec_scanline_order_t sk_codec_get_scanline_order(sk_codec_t* codec); 34 | SK_C_API int sk_codec_next_scanline(sk_codec_t* codec); 35 | SK_C_API int sk_codec_output_scanline(sk_codec_t* codec, int inputScanline); 36 | SK_C_API int sk_codec_get_frame_count(sk_codec_t* codec); 37 | SK_C_API void sk_codec_get_frame_info(sk_codec_t* codec, sk_codec_frameinfo_t* frameInfo); 38 | SK_C_API bool sk_codec_get_frame_info_for_index(sk_codec_t* codec, int index, sk_codec_frameinfo_t* frameInfo); 39 | SK_C_API int sk_codec_get_repetition_count(sk_codec_t* codec); 40 | 41 | SK_C_PLUS_PLUS_END_GUARD 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /include/c/sk_surface.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_surface_DEFINED 11 | #define sk_surface_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | // surface 18 | 19 | SK_C_API sk_surface_t* sk_surface_new_null(int width, int height); 20 | SK_C_API sk_surface_t* sk_surface_new_raster(const sk_imageinfo_t*, size_t rowBytes, const sk_surfaceprops_t*); 21 | SK_C_API sk_surface_t* sk_surface_new_raster_direct(const sk_imageinfo_t*, void* pixels, size_t rowBytes, const sk_surface_raster_release_proc releaseProc, void* context, const sk_surfaceprops_t* props); 22 | 23 | SK_C_API sk_surface_t* sk_surface_new_backend_texture(gr_context_t* context, const gr_backendtexture_t* texture, gr_surfaceorigin_t origin, int samples, sk_colortype_t colorType, sk_colorspace_t* colorspace, const sk_surfaceprops_t* props); 24 | SK_C_API sk_surface_t* sk_surface_new_backend_render_target(gr_context_t* context, const gr_backendrendertarget_t* target, gr_surfaceorigin_t origin, sk_colortype_t colorType, sk_colorspace_t* colorspace, const sk_surfaceprops_t* props); 25 | SK_C_API sk_surface_t* sk_surface_new_backend_texture_as_render_target(gr_context_t* context, const gr_backendtexture_t* texture, gr_surfaceorigin_t origin, int samples, sk_colortype_t colorType, sk_colorspace_t* colorspace, const sk_surfaceprops_t* props); 26 | SK_C_API sk_surface_t* sk_surface_new_render_target(gr_context_t* context, bool budgeted, const sk_imageinfo_t* cinfo, int sampleCount, gr_surfaceorigin_t origin, const sk_surfaceprops_t* props, bool shouldCreateWithMips); 27 | 28 | SK_C_API void sk_surface_unref(sk_surface_t*); 29 | SK_C_API sk_canvas_t* sk_surface_get_canvas(sk_surface_t*); 30 | SK_C_API sk_image_t* sk_surface_new_image_snapshot(sk_surface_t*); 31 | SK_C_API void sk_surface_draw(sk_surface_t* surface, sk_canvas_t* canvas, float x, float y, const sk_paint_t* paint); 32 | SK_C_API bool sk_surface_peek_pixels(sk_surface_t* surface, sk_pixmap_t* pixmap); 33 | SK_C_API bool sk_surface_read_pixels(sk_surface_t* surface, sk_imageinfo_t* dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY); 34 | SK_C_API const sk_surfaceprops_t* sk_surface_get_props(sk_surface_t* surface); 35 | 36 | // surface props 37 | 38 | SK_C_API sk_surfaceprops_t* sk_surfaceprops_new(uint32_t flags, sk_pixelgeometry_t geometry); 39 | SK_C_API void sk_surfaceprops_delete(sk_surfaceprops_t* props); 40 | SK_C_API uint32_t sk_surfaceprops_get_flags(sk_surfaceprops_t* props); 41 | SK_C_API sk_pixelgeometry_t sk_surfaceprops_get_pixel_geometry(sk_surfaceprops_t* props); 42 | 43 | SK_C_PLUS_PLUS_END_GUARD 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /include/c/sk_pixmap.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_pixmap_DEFINED 11 | #define sk_pixmap_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_pixmap_destructor(sk_pixmap_t* cpixmap); 18 | SK_C_API sk_pixmap_t* sk_pixmap_new(void); 19 | SK_C_API sk_pixmap_t* sk_pixmap_new_with_params(const sk_imageinfo_t* cinfo, const void* addr, size_t rowBytes); 20 | SK_C_API void sk_pixmap_reset(sk_pixmap_t* cpixmap); 21 | SK_C_API void sk_pixmap_reset_with_params(sk_pixmap_t* cpixmap, const sk_imageinfo_t* cinfo, const void* addr, size_t rowBytes); 22 | SK_C_API void sk_pixmap_get_info(const sk_pixmap_t* cpixmap, sk_imageinfo_t* cinfo); 23 | SK_C_API size_t sk_pixmap_get_row_bytes(const sk_pixmap_t* cpixmap); 24 | SK_C_API const void* sk_pixmap_get_pixels(const sk_pixmap_t* cpixmap); 25 | SK_C_API const void* sk_pixmap_get_pixels_with_xy(const sk_pixmap_t* cpixmap, int x, int y); 26 | SK_C_API sk_color_t sk_pixmap_get_pixel_color(const sk_pixmap_t* cpixmap, int x, int y); 27 | SK_C_API bool sk_pixmap_encode_image(sk_wstream_t* dst, const sk_pixmap_t* src, sk_encoded_image_format_t encoder, int quality); 28 | SK_C_API bool sk_pixmap_read_pixels(const sk_pixmap_t* cpixmap, const sk_imageinfo_t* dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY, sk_transfer_function_behavior_t behavior); 29 | SK_C_API bool sk_pixmap_scale_pixels(const sk_pixmap_t* cpixmap, const sk_pixmap_t* dst, sk_filter_quality_t quality); 30 | SK_C_API bool sk_pixmap_extract_subset(const sk_pixmap_t* cpixmap, sk_pixmap_t* result, const sk_irect_t* subset); 31 | SK_C_API bool sk_pixmap_erase_color(const sk_pixmap_t* cpixmap, sk_color_t color, const sk_irect_t* subset); 32 | 33 | SK_C_API sk_color_t sk_color_unpremultiply(const sk_pmcolor_t pmcolor); 34 | SK_C_API sk_pmcolor_t sk_color_premultiply(const sk_color_t color); 35 | SK_C_API void sk_color_unpremultiply_array(const sk_pmcolor_t* pmcolors, int size, sk_color_t* colors); 36 | SK_C_API void sk_color_premultiply_array(const sk_color_t* colors, int size, sk_pmcolor_t* pmcolors); 37 | SK_C_API void sk_color_get_bit_shift(int* a, int* r, int* g, int* b); 38 | 39 | SK_C_API void sk_swizzle_swap_rb(uint32_t* dest, const uint32_t* src, int count); 40 | 41 | SK_C_API bool sk_webpencoder_encode(sk_wstream_t* dst, const sk_pixmap_t* src, sk_webpencoder_options_t options); 42 | SK_C_API bool sk_jpegencoder_encode(sk_wstream_t* dst, const sk_pixmap_t* src, sk_jpegencoder_options_t options); 43 | SK_C_API bool sk_pngencoder_encode(sk_wstream_t* dst, const sk_pixmap_t* src, sk_pngencoder_options_t options); 44 | 45 | SK_C_PLUS_PLUS_END_GUARD 46 | 47 | #endif 48 | -------------------------------------------------------------------------------- /include/c/sk_colorspace.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_colorspace_DEFINED 11 | #define sk_colorspace_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_colorspace_unref(sk_colorspace_t* cColorSpace); 18 | SK_C_API sk_colorspace_t* sk_colorspace_new_srgb(void); 19 | SK_C_API sk_colorspace_t* sk_colorspace_new_srgb_linear(void); 20 | SK_C_API sk_colorspace_t* sk_colorspace_new_icc(const void* input, size_t len); 21 | SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50); 22 | SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut); 23 | SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50); 24 | SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut); 25 | SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_named(sk_gamma_named_t gamma, const sk_matrix44_t* toXYZD50); 26 | SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_named_and_gamut(sk_gamma_named_t gamma, sk_colorspace_gamut_t gamut); 27 | SK_C_API sk_colorspace_type_t sk_colorspace_gamma_get_type(const sk_colorspace_t* cColorSpace); 28 | SK_C_API sk_gamma_named_t sk_colorspace_gamma_get_gamma_named(const sk_colorspace_t* cColorSpace); 29 | SK_C_API bool sk_colorspace_gamma_close_to_srgb(const sk_colorspace_t* cColorSpace); 30 | SK_C_API bool sk_colorspace_gamma_is_linear(const sk_colorspace_t* cColorSpace); 31 | SK_C_API bool sk_colorspace_is_srgb(const sk_colorspace_t* cColorSpace); 32 | SK_C_API bool sk_colorspace_equals(const sk_colorspace_t* src, const sk_colorspace_t* dst); 33 | SK_C_API bool sk_colorspace_to_xyzd50(const sk_colorspace_t* cColorSpace, sk_matrix44_t* toXYZD50); 34 | SK_C_API const sk_matrix44_t* sk_colorspace_as_to_xyzd50(const sk_colorspace_t* cColorSpace); 35 | SK_C_API const sk_matrix44_t* sk_colorspace_as_from_xyzd50(const sk_colorspace_t* cColorSpace); 36 | SK_C_API bool sk_colorspace_is_numerical_transfer_fn(const sk_colorspace_t* cColorSpace, sk_colorspace_transfer_fn_t* fn); 37 | SK_C_API bool sk_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50); 38 | SK_C_API void sk_colorspace_transfer_fn_invert(const sk_colorspace_transfer_fn_t* transfer, sk_colorspace_transfer_fn_t* inverted); 39 | SK_C_API float sk_colorspace_transfer_fn_transform(const sk_colorspace_transfer_fn_t* transfer, float x); 40 | 41 | SK_C_PLUS_PLUS_END_GUARD 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /include/c/sk_bitmap.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_bitmap_DEFINED 11 | #define sk_bitmap_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_bitmap_destructor(sk_bitmap_t* cbitmap); 18 | SK_C_API sk_bitmap_t* sk_bitmap_new(void); 19 | SK_C_API void sk_bitmap_get_info(sk_bitmap_t* cbitmap, sk_imageinfo_t* info); 20 | SK_C_API void* sk_bitmap_get_pixels(sk_bitmap_t* cbitmap, size_t* length); 21 | SK_C_API size_t sk_bitmap_get_row_bytes(sk_bitmap_t* cbitmap); 22 | SK_C_API size_t sk_bitmap_get_byte_count(sk_bitmap_t* cbitmap); 23 | SK_C_API void sk_bitmap_reset(sk_bitmap_t* cbitmap); 24 | SK_C_API bool sk_bitmap_is_null(sk_bitmap_t* cbitmap); 25 | SK_C_API bool sk_bitmap_is_immutable(sk_bitmap_t* cbitmap); 26 | SK_C_API void sk_bitmap_set_immutable(sk_bitmap_t* cbitmap); 27 | SK_C_API bool sk_bitmap_is_volatile(sk_bitmap_t* cbitmap); 28 | SK_C_API void sk_bitmap_set_volatile(sk_bitmap_t* cbitmap, bool value); 29 | SK_C_API void sk_bitmap_erase(sk_bitmap_t* cbitmap, sk_color_t color); 30 | SK_C_API void sk_bitmap_erase_rect(sk_bitmap_t* cbitmap, sk_color_t color, sk_irect_t* rect); 31 | SK_C_API uint8_t sk_bitmap_get_addr_8(sk_bitmap_t* cbitmap, int x, int y); 32 | SK_C_API uint16_t sk_bitmap_get_addr_16(sk_bitmap_t* cbitmap, int x, int y); 33 | SK_C_API uint32_t sk_bitmap_get_addr_32(sk_bitmap_t* cbitmap, int x, int y); 34 | SK_C_API void* sk_bitmap_get_addr(sk_bitmap_t* cbitmap, int x, int y); 35 | SK_C_API sk_color_t sk_bitmap_get_pixel_color(sk_bitmap_t* cbitmap, int x, int y); 36 | SK_C_API void sk_bitmap_set_pixel_color(sk_bitmap_t* cbitmap, int x, int y, sk_color_t color); 37 | SK_C_API bool sk_bitmap_ready_to_draw(sk_bitmap_t* cbitmap); 38 | SK_C_API void sk_bitmap_get_pixel_colors(sk_bitmap_t* cbitmap, sk_color_t* colors); 39 | SK_C_API void sk_bitmap_set_pixel_colors(sk_bitmap_t* cbitmap, const sk_color_t* colors); 40 | SK_C_API bool sk_bitmap_install_pixels(sk_bitmap_t* cbitmap, const sk_imageinfo_t* cinfo, void* pixels, size_t rowBytes, const sk_bitmap_release_proc releaseProc, void* context); 41 | SK_C_API bool sk_bitmap_install_pixels_with_pixmap(sk_bitmap_t* cbitmap, const sk_pixmap_t* cpixmap); 42 | SK_C_API bool sk_bitmap_install_mask_pixels(sk_bitmap_t* cbitmap, const sk_mask_t* cmask); 43 | SK_C_API bool sk_bitmap_try_alloc_pixels(sk_bitmap_t* cbitmap, const sk_imageinfo_t* requestedInfo, size_t rowBytes); 44 | SK_C_API bool sk_bitmap_try_alloc_pixels_with_flags(sk_bitmap_t* cbitmap, const sk_imageinfo_t* requestedInfo, uint32_t flags); 45 | SK_C_API void sk_bitmap_set_pixels(sk_bitmap_t* cbitmap, void* pixels); 46 | SK_C_API bool sk_bitmap_peek_pixels(sk_bitmap_t* cbitmap, sk_pixmap_t* cpixmap); 47 | SK_C_API bool sk_bitmap_extract_subset(sk_bitmap_t* cbitmap, sk_bitmap_t* dst, sk_irect_t* subset); 48 | SK_C_API bool sk_bitmap_extract_alpha(sk_bitmap_t* cbitmap, sk_bitmap_t* dst, const sk_paint_t* paint, sk_ipoint_t* offset); 49 | SK_C_API void sk_bitmap_notify_pixels_changed(sk_bitmap_t* cbitmap); 50 | SK_C_API void sk_bitmap_swap(sk_bitmap_t* cbitmap, sk_bitmap_t* cother); 51 | 52 | SK_C_PLUS_PLUS_END_GUARD 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /include/c/sk_image.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_image_DEFINED 11 | #define sk_image_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_image_t* sk_image_new_raster_copy(const sk_imageinfo_t*, const void* pixels, size_t rowBytes); 18 | SK_C_API sk_image_t* sk_image_new_raster_copy_with_pixmap(const sk_pixmap_t* pixmap); 19 | SK_C_API sk_image_t* sk_image_new_raster_data(const sk_imageinfo_t* cinfo, sk_data_t* pixels, size_t rowBytes); 20 | SK_C_API sk_image_t* sk_image_new_raster(const sk_pixmap_t* pixmap, sk_image_raster_release_proc releaseProc, void* context); 21 | SK_C_API sk_image_t* sk_image_new_from_bitmap(const sk_bitmap_t *cbitmap); 22 | SK_C_API sk_image_t* sk_image_new_from_encoded(sk_data_t* encoded, const sk_irect_t* subset); 23 | SK_C_API sk_image_t* sk_image_new_from_texture(gr_context_t* context, const gr_backendtexture_t* texture, gr_surfaceorigin_t origin, sk_colortype_t colorType, sk_alphatype_t alpha, sk_colorspace_t* colorSpace, sk_image_texture_release_proc releaseProc, void* releaseContext); 24 | SK_C_API sk_image_t* sk_image_new_from_adopted_texture(gr_context_t* context, const gr_backendtexture_t* texture, gr_surfaceorigin_t origin, sk_colortype_t colorType, sk_alphatype_t alpha, sk_colorspace_t* colorSpace); 25 | SK_C_API sk_image_t* sk_image_new_from_picture(sk_picture_t* picture, const sk_isize_t* dimensions, const sk_matrix_t* matrix, const sk_paint_t* paint); 26 | 27 | SK_C_API sk_image_t* sk_image_make_subset(const sk_image_t* cimage, const sk_irect_t* subset); 28 | SK_C_API sk_image_t* sk_image_make_non_texture_image(const sk_image_t* cimage); 29 | SK_C_API sk_image_t* sk_image_make_with_filter(const sk_image_t* cimage, const sk_imagefilter_t* filter, const sk_irect_t* subset, const sk_irect_t* clipBounds, sk_irect_t* outSubset, sk_ipoint_t* outOffset); 30 | 31 | SK_C_API void sk_image_ref(const sk_image_t*); 32 | SK_C_API void sk_image_unref(const sk_image_t*); 33 | SK_C_API int sk_image_get_width(const sk_image_t*); 34 | SK_C_API int sk_image_get_height(const sk_image_t*); 35 | SK_C_API uint32_t sk_image_get_unique_id(const sk_image_t*); 36 | SK_C_API sk_alphatype_t sk_image_get_alpha_type(const sk_image_t*); 37 | SK_C_API sk_colortype_t sk_image_get_color_type(const sk_image_t*); 38 | SK_C_API sk_colorspace_t* sk_image_get_colorspace(const sk_image_t*); 39 | SK_C_API bool sk_image_is_alpha_only(const sk_image_t*); 40 | SK_C_API sk_shader_t* sk_image_make_shader(const sk_image_t*, sk_shader_tilemode_t tileX, sk_shader_tilemode_t tileY, const sk_matrix_t* localMatrix); 41 | SK_C_API bool sk_image_peek_pixels(const sk_image_t* image, sk_pixmap_t* pixmap); 42 | SK_C_API bool sk_image_is_texture_backed(const sk_image_t* image); 43 | SK_C_API bool sk_image_is_lazy_generated(const sk_image_t* image); 44 | SK_C_API bool sk_image_read_pixels(const sk_image_t* image, const sk_imageinfo_t* dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY, sk_image_caching_hint_t cachingHint); 45 | SK_C_API bool sk_image_read_pixels_into_pixmap(const sk_image_t* image, const sk_pixmap_t* dst, int srcX, int srcY, sk_image_caching_hint_t cachingHint); 46 | SK_C_API bool sk_image_scale_pixels(const sk_image_t* image, const sk_pixmap_t* dst, sk_filter_quality_t quality, sk_image_caching_hint_t cachingHint); 47 | SK_C_API sk_data_t* sk_image_ref_encoded(const sk_image_t*); 48 | SK_C_API sk_data_t* sk_image_encode(const sk_image_t*); 49 | SK_C_API sk_data_t* sk_image_encode_specific(const sk_image_t* cimage, sk_encoded_image_format_t encoder, int quality); 50 | 51 | SK_C_PLUS_PLUS_END_GUARD 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /include/c/gr_context.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef gr_context_DEFINED 11 | #define gr_context_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | 18 | // GrContext 19 | 20 | SK_C_API gr_context_t* gr_context_make_gl(const gr_glinterface_t* glInterface); 21 | // TODO: the overloads with GrContextOptions 22 | // TODO: the Vulkan and Metal contexts 23 | 24 | SK_C_API void gr_context_unref(gr_context_t* context); 25 | SK_C_API void gr_context_abandon_context(gr_context_t* context); 26 | SK_C_API void gr_context_release_resources_and_abandon_context(gr_context_t* context); 27 | SK_C_API void gr_context_get_resource_cache_limits(gr_context_t* context, int* maxResources, size_t* maxResourceBytes); 28 | SK_C_API void gr_context_set_resource_cache_limits(gr_context_t* context, int maxResources, size_t maxResourceBytes); 29 | SK_C_API void gr_context_get_resource_cache_usage(gr_context_t* context, int* maxResources, size_t* maxResourceBytes); 30 | SK_C_API int gr_context_get_max_surface_sample_count_for_color_type(gr_context_t* context, sk_colortype_t colorType); 31 | SK_C_API void gr_context_flush(gr_context_t* context); 32 | SK_C_API void gr_context_reset_context(gr_context_t* context, uint32_t state); 33 | SK_C_API gr_backend_t gr_context_get_backend(gr_context_t* context); 34 | 35 | 36 | // GrGLInterface 37 | 38 | SK_C_API const gr_glinterface_t* gr_glinterface_create_native_interface(void); 39 | SK_C_API const gr_glinterface_t* gr_glinterface_assemble_interface(void* ctx, gr_gl_get_proc get); 40 | SK_C_API const gr_glinterface_t* gr_glinterface_assemble_gl_interface(void* ctx, gr_gl_get_proc get); 41 | SK_C_API const gr_glinterface_t* gr_glinterface_assemble_gles_interface(void* ctx, gr_gl_get_proc get); 42 | 43 | SK_C_API void gr_glinterface_unref(const gr_glinterface_t* glInterface); 44 | SK_C_API bool gr_glinterface_validate(const gr_glinterface_t* glInterface); 45 | SK_C_API bool gr_glinterface_has_extension(const gr_glinterface_t* glInterface, const char* extension); 46 | 47 | 48 | // GrBackendTexture 49 | 50 | SK_C_API gr_backendtexture_t* gr_backendtexture_new_gl(int width, int height, bool mipmapped, const gr_gl_textureinfo_t* glInfo); 51 | SK_C_API void gr_backendtexture_delete(gr_backendtexture_t* texture); 52 | 53 | SK_C_API bool gr_backendtexture_is_valid(const gr_backendtexture_t* texture); 54 | SK_C_API int gr_backendtexture_get_width(const gr_backendtexture_t* texture); 55 | SK_C_API int gr_backendtexture_get_height(const gr_backendtexture_t* texture); 56 | SK_C_API bool gr_backendtexture_has_mipmaps(const gr_backendtexture_t* texture); 57 | SK_C_API gr_backend_t gr_backendtexture_get_backend(const gr_backendtexture_t* texture); 58 | SK_C_API bool gr_backendtexture_get_gl_textureinfo(const gr_backendtexture_t* texture, gr_gl_textureinfo_t* glInfo); 59 | 60 | 61 | // GrBackendRenderTarget 62 | 63 | SK_C_API gr_backendrendertarget_t* gr_backendrendertarget_new_gl(int width, int height, int samples, int stencils, const gr_gl_framebufferinfo_t* glInfo); 64 | SK_C_API void gr_backendrendertarget_delete(gr_backendrendertarget_t* rendertarget); 65 | 66 | SK_C_API bool gr_backendrendertarget_is_valid(const gr_backendrendertarget_t* rendertarget); 67 | SK_C_API int gr_backendrendertarget_get_width(const gr_backendrendertarget_t* rendertarget); 68 | SK_C_API int gr_backendrendertarget_get_height(const gr_backendrendertarget_t* rendertarget); 69 | SK_C_API int gr_backendrendertarget_get_samples(const gr_backendrendertarget_t* rendertarget); 70 | SK_C_API int gr_backendrendertarget_get_stencils(const gr_backendrendertarget_t* rendertarget); 71 | SK_C_API gr_backend_t gr_backendrendertarget_get_backend(const gr_backendrendertarget_t* rendertarget); 72 | SK_C_API bool gr_backendrendertarget_get_gl_framebufferinfo(const gr_backendrendertarget_t* rendertarget, gr_gl_framebufferinfo_t* glInfo); 73 | 74 | 75 | SK_C_PLUS_PLUS_END_GUARD 76 | 77 | #endif 78 | -------------------------------------------------------------------------------- /include/c/sk_shader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_shader_DEFINED 11 | #define sk_shader_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_shader_ref(sk_shader_t*); 18 | SK_C_API void sk_shader_unref(sk_shader_t*); 19 | SK_C_API sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t points[2], 20 | const sk_color_t colors[], 21 | const float colorPos[], 22 | int colorCount, 23 | sk_shader_tilemode_t tileMode, 24 | const sk_matrix_t* localMatrix); 25 | SK_C_API sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* center, 26 | float radius, 27 | const sk_color_t colors[], 28 | const float colorPos[], 29 | int colorCount, 30 | sk_shader_tilemode_t tileMode, 31 | const sk_matrix_t* localMatrix); 32 | SK_C_API sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* center, 33 | const sk_color_t colors[], 34 | const float colorPos[], 35 | int colorCount, 36 | sk_shader_tilemode_t tileMode, 37 | float startAngle, 38 | float endAngle, 39 | const sk_matrix_t* localMatrix); 40 | SK_C_API sk_shader_t* sk_shader_new_two_point_conical_gradient( 41 | const sk_point_t* start, 42 | float startRadius, 43 | const sk_point_t* end, 44 | float endRadius, 45 | const sk_color_t colors[], 46 | const float colorPos[], 47 | int colorCount, 48 | sk_shader_tilemode_t tileMode, 49 | const sk_matrix_t* localMatrix); 50 | SK_C_API sk_shader_t* sk_shader_new_empty(void); 51 | SK_C_API sk_shader_t* sk_shader_new_color(sk_color_t color); 52 | SK_C_API sk_shader_t* sk_shader_new_bitmap(const sk_bitmap_t* src, 53 | sk_shader_tilemode_t tmx, 54 | sk_shader_tilemode_t tmy, 55 | const sk_matrix_t* localMatrix); 56 | SK_C_API sk_shader_t* sk_shader_new_picture(sk_picture_t* src, 57 | sk_shader_tilemode_t tmx, 58 | sk_shader_tilemode_t tmy, 59 | const sk_matrix_t* localMatrix, 60 | const sk_rect_t* tile); 61 | SK_C_API sk_shader_t* sk_shader_new_local_matrix(sk_shader_t* proxy, const sk_matrix_t* localMatrix); 62 | SK_C_API sk_shader_t* sk_shader_new_color_filter(sk_shader_t* proxy, sk_colorfilter_t* filter); 63 | SK_C_API sk_shader_t* sk_shader_new_perlin_noise_fractal_noise( 64 | float baseFrequencyX, 65 | float baseFrequencyY, 66 | int numOctaves, 67 | float seed, 68 | const sk_isize_t* tileSize); 69 | SK_C_API sk_shader_t* sk_shader_new_perlin_noise_turbulence( 70 | float baseFrequencyX, 71 | float baseFrequencyY, 72 | int numOctaves, 73 | float seed, 74 | const sk_isize_t* tileSize); 75 | SK_C_API sk_shader_t* sk_shader_new_perlin_noise_improved_noise( 76 | float baseFrequencyX, 77 | float baseFrequencyY, 78 | int numOctaves, 79 | float z); 80 | SK_C_API sk_shader_t* sk_shader_new_compose( 81 | sk_shader_t* shaderA, 82 | sk_shader_t* shaderB); 83 | SK_C_API sk_shader_t* sk_shader_new_compose_with_mode( 84 | sk_shader_t* shaderA, 85 | sk_shader_t* shaderB, 86 | sk_blendmode_t mode); 87 | 88 | SK_C_PLUS_PLUS_END_GUARD 89 | 90 | #endif 91 | -------------------------------------------------------------------------------- /include/c/sk_typeface.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_typeface_DEFINED 11 | #define sk_typeface_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | // typeface 18 | 19 | SK_C_API sk_typeface_t* sk_typeface_create_default(void); 20 | SK_C_API sk_typeface_t* sk_typeface_ref_default(void); 21 | SK_C_API sk_typeface_t* sk_typeface_create_from_name_with_font_style(const char* familyName, sk_fontstyle_t* style); 22 | SK_C_API void sk_typeface_unref(sk_typeface_t*); 23 | SK_C_API sk_typeface_t* sk_typeface_create_from_file(const char* path, int index); 24 | SK_C_API sk_typeface_t* sk_typeface_create_from_stream(sk_stream_asset_t* stream, int index); 25 | SK_C_API int sk_typeface_chars_to_glyphs(sk_typeface_t* typeface, const char* chars, sk_encoding_t encoding, uint16_t glyphs[], int glyphCount); 26 | SK_C_API sk_stream_asset_t* sk_typeface_open_stream(sk_typeface_t* typeface, int* ttcIndex); 27 | SK_C_API int sk_typeface_get_units_per_em(sk_typeface_t* typeface); 28 | SK_C_API sk_string_t* sk_typeface_get_family_name(sk_typeface_t* typeface); 29 | SK_C_API sk_fontstyle_t* sk_typeface_get_fontstyle(sk_typeface_t* typeface); 30 | SK_C_API int sk_typeface_get_font_weight(sk_typeface_t* typeface); 31 | SK_C_API int sk_typeface_get_font_width(sk_typeface_t* typeface); 32 | SK_C_API sk_font_style_slant_t sk_typeface_get_font_slant(sk_typeface_t* typeface); 33 | SK_C_API int sk_typeface_count_tables(sk_typeface_t* typeface); 34 | SK_C_API int sk_typeface_get_table_tags(sk_typeface_t* typeface, sk_font_table_tag_t tags[]); 35 | SK_C_API size_t sk_typeface_get_table_size(sk_typeface_t* typeface, sk_font_table_tag_t tag); 36 | SK_C_API size_t sk_typeface_get_table_data(sk_typeface_t* typeface, sk_font_table_tag_t tag, size_t offset, size_t length, void* data); 37 | SK_C_API bool sk_typeface_is_fixed_pitch(sk_typeface_t* typeface); 38 | 39 | // font manager 40 | 41 | SK_C_API sk_fontmgr_t* sk_fontmgr_create_default(void); 42 | SK_C_API sk_fontmgr_t* sk_fontmgr_ref_default(void); 43 | SK_C_API void sk_fontmgr_unref(sk_fontmgr_t*); 44 | SK_C_API int sk_fontmgr_count_families(sk_fontmgr_t*); 45 | SK_C_API void sk_fontmgr_get_family_name(sk_fontmgr_t*, int index, sk_string_t* familyName); 46 | SK_C_API sk_fontstyleset_t* sk_fontmgr_create_styleset(sk_fontmgr_t*, int index); 47 | SK_C_API sk_fontstyleset_t* sk_fontmgr_match_family(sk_fontmgr_t*, const char* familyName); 48 | SK_C_API sk_typeface_t* sk_fontmgr_match_family_style(sk_fontmgr_t*, const char* familyName, sk_fontstyle_t* style); 49 | SK_C_API sk_typeface_t* sk_fontmgr_match_family_style_character(sk_fontmgr_t*, const char* familyName, sk_fontstyle_t* style, const char** bcp47, int bcp47Count, int32_t character); 50 | SK_C_API sk_typeface_t* sk_fontmgr_match_face_style(sk_fontmgr_t*, const sk_typeface_t* face, sk_fontstyle_t* style); 51 | SK_C_API sk_typeface_t* sk_fontmgr_create_from_data(sk_fontmgr_t*, sk_data_t* data, int index); 52 | SK_C_API sk_typeface_t* sk_fontmgr_create_from_stream(sk_fontmgr_t*, sk_stream_asset_t* stream, int index); 53 | SK_C_API sk_typeface_t* sk_fontmgr_create_from_file(sk_fontmgr_t*, const char* path, int index); 54 | 55 | // font style 56 | 57 | SK_C_API sk_fontstyle_t* sk_fontstyle_new(int weight, int width, sk_font_style_slant_t slant); 58 | SK_C_API void sk_fontstyle_delete(sk_fontstyle_t* fs); 59 | SK_C_API int sk_fontstyle_get_weight(const sk_fontstyle_t* fs); 60 | SK_C_API int sk_fontstyle_get_width(const sk_fontstyle_t* fs); 61 | SK_C_API sk_font_style_slant_t sk_fontstyle_get_slant(const sk_fontstyle_t* fs); 62 | 63 | // font style set 64 | 65 | SK_C_API sk_fontstyleset_t* sk_fontstyleset_create_empty(); 66 | SK_C_API void sk_fontstyleset_unref(sk_fontstyleset_t* fss); 67 | SK_C_API int sk_fontstyleset_get_count(sk_fontstyleset_t* fss); 68 | SK_C_API void sk_fontstyleset_get_style(sk_fontstyleset_t* fss, int index, sk_fontstyle_t* fs, sk_string_t* style); 69 | SK_C_API sk_typeface_t* sk_fontstyleset_create_typeface(sk_fontstyleset_t* fss, int index); 70 | SK_C_API sk_typeface_t* sk_fontstyleset_match_style(sk_fontstyleset_t* fss, sk_fontstyle_t* style); 71 | 72 | SK_C_PLUS_PLUS_END_GUARD 73 | 74 | #endif 75 | -------------------------------------------------------------------------------- /examples/rain.js: -------------------------------------------------------------------------------- 1 | const { performance } = require('perf_hooks'); 2 | const skia = require('../generated/interface'); 3 | const glfw = require('glfw-n-api'); 4 | 5 | Object.assign(global, glfw); 6 | Object.assign(global, skia); 7 | 8 | function error_callback(error, description) { 9 | console.log(arguments); 10 | } 11 | 12 | function key_callback(window, key, scancode, action, mods) { 13 | console.log(window, key, scancode, action, mods); 14 | if (key == 256 && action == 1) { 15 | glfwSetWindowShouldClose(window, GL_TRUE); 16 | } 17 | } 18 | 19 | const kWidth = 1280; 20 | const kHeight = 720; 21 | 22 | let window; 23 | glfwSetErrorCallback(error_callback); 24 | if (!glfwInit()) { 25 | process.exit(1); 26 | } 27 | 28 | glfwWindowHint(0x00022002, 3); 29 | glfwWindowHint(0x00022003, 2); 30 | glfwWindowHint(0x00022006, GL_TRUE); 31 | glfwWindowHint(0x00022008, 0x00032001); 32 | //(uncomment to enable correct color spaces) glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE); 33 | glfwWindowHint(0x00021006, 0); 34 | //glfwWindowHint(GLFW_ALPHA_BITS, 0); 35 | glfwWindowHint(0x00021005, 0); 36 | 37 | window = glfwCreateWindow(kWidth, kHeight, "Simple example", null, null); 38 | if (!window) { 39 | glfwTerminate(); 40 | process.exit(1); 41 | } 42 | glfwMakeContextCurrent(window); 43 | //(uncomment to enable correct color spaces) glEnable(GL_FRAMEBUFFER_SRGB); 44 | let width = new Int32Array([0]); 45 | let height = new Int32Array([0]); 46 | const widthP = getAddress(width.buffer); 47 | const heightP = getAddress(height.buffer); 48 | 49 | glfwGetFramebufferSize(window, widthP, heightP); 50 | let devicePixelRatio = width[0] / kWidth; 51 | 52 | const glInterface = grGlinterfaceCreateNativeInterface(); 53 | const context = grContextMakeGl(glInterface); 54 | const glInfo = new Int32Array([0, GL_RGBA8]); 55 | const target = grBackendrendertargetNewGl(width[0], height[0], 0, 0, glInfo.buffer); 56 | const surface = skSurfaceNewBackendRenderTarget(context, target, enums.BOTTOM_LEFT_GR_SURFACE_ORIGIN, enums.RGBA_8888_SK_COLORTYPE, null, null); 57 | 58 | glfwSwapInterval(1); 59 | glfwSetKeyCallback(window, key_callback); 60 | const canvas = skSurfaceGetCanvas(surface); 61 | 62 | 63 | 64 | const w = 1280; 65 | const h = 720; 66 | 67 | //parameters 68 | total = w, 69 | accelleration = .1, 70 | 71 | //afterinitial calculations 72 | size = w/total, 73 | occupation = w/total, 74 | colors = [], 75 | dots = [], 76 | dotsVel = []; 77 | 78 | //setting the colors' hue 79 | //and y level for all dots 80 | var portion = 255/total; 81 | for(var i = 0; i < total; ++i){ 82 | colors[i] = portion * i; 83 | 84 | dots[i] = h; 85 | dotsVel[i] = 10; 86 | } 87 | 88 | function draw(){ 89 | skCanvasSave(canvas); 90 | skCanvasScale(canvas, devicePixelRatio, devicePixelRatio); 91 | 92 | const fill = skPaintNew(); 93 | skPaintSetColor(fill, skColorSetArgb(0xFF, 0x00, 0x00, 0x00)); 94 | skCanvasDrawPaint(canvas, fill); 95 | 96 | for(var i = 0; i < total; ++i){ 97 | var currentY = dots[i] - 1; 98 | dots[i] += dotsVel[i] += accelleration; 99 | 100 | skPaintSetColor(fill, skColorSetArgb(0xFF, colors[i], 255-colors[i], 255)); 101 | const rect = new skRect({ 102 | left: occupation * i, 103 | top: currentY, 104 | right: occupation * i + size, 105 | bottom: currentY + dotsVel[i] + 1 106 | }); 107 | skCanvasDrawRect(canvas, rect, fill); 108 | 109 | if(dots[i] > h && Math.random() < .01){ 110 | dots[i] = dotsVel[i] = 0; 111 | } 112 | } 113 | 114 | skCanvasRestore(canvas); 115 | } 116 | 117 | let frames = 0; 118 | let t0 = 0; 119 | let previous = glfwGetTime(); 120 | function drawLoop() { 121 | if (!glfwWindowShouldClose(window)) { 122 | setTimeout(() => { 123 | const t = performance.now(); 124 | if (t - t0 > 1000.0 || frames === 0) { 125 | const fps = Math.floor((frames / (t - t0)) * 1e3); 126 | glfwSetWindowTitle(window, `FPS: ${fps}`); 127 | t0 = t; 128 | frames = 0; 129 | } 130 | frames++; 131 | 132 | drawLoop(); 133 | }, 0); 134 | } else { 135 | glfwDestroyWindow(window); 136 | glfwTerminate(); 137 | process.exit(0); 138 | } 139 | 140 | let now = glfwGetTime(); 141 | let delta = now - previous; 142 | previous = now; 143 | 144 | draw(canvas, devicePixelRatio, now); 145 | 146 | grContextFlush(context); 147 | 148 | glfwSwapBuffers(window); 149 | 150 | glfwPollEvents(); 151 | } 152 | drawLoop(); 153 | -------------------------------------------------------------------------------- /examples/index.js: -------------------------------------------------------------------------------- 1 | const fs = require('fs'); 2 | const skia = require('../generated/interface'); 3 | 4 | Object.assign(global, skia); 5 | 6 | const info = new Int32Array([ 7 | 0, 0, 1280, 720, enums.RGBA_8888_SK_COLORTYPE, enums.OPAQUE_SK_ALPHATYPE 8 | ]); 9 | const surface = skSurfaceNewRaster(info.buffer, 1280*4, null); 10 | const canvas = skSurfaceGetCanvas(surface); 11 | 12 | function draw(canvas) { 13 | 14 | const fill = skPaintNew(); 15 | skPaintSetColor(fill, skColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 16 | skCanvasDrawPaint(canvas, fill); 17 | 18 | skPaintSetColor(fill, skColorSetArgb(0xFF, 0xFF, 0x00, 0xFF)); 19 | const rect = new Float32Array([ 20 | 100, 21 | 100, 22 | 540, 23 | 380 24 | ]); 25 | skCanvasDrawRect(canvas, rect.buffer, fill); 26 | 27 | const stroke = skPaintNew(); 28 | skPaintSetColor(stroke, skColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 29 | skPaintSetAntialias(stroke, true); 30 | skPaintSetStyle(stroke, enums.STROKE_SK_PAINT_STYLE); 31 | skPaintSetStrokeWidth(stroke, 5.0); 32 | const path = skPathNew(); 33 | 34 | skPathMoveTo(path, 50.0, 50.0); 35 | skPathLineTo(path, 590.0, 50.0); 36 | skPathCubicTo(path, -490.0, 50.0, 1130.0, 430.0, 50.0, 430.0); 37 | skPathLineTo(path, 590.0, 430.0); 38 | const intervals = new Float32Array([10, 20]); 39 | const effect = skPathEffectCreateDash(intervals.buffer, 2, 25); 40 | skPaintSetPathEffect(stroke, effect); 41 | skCanvasDrawPath(canvas, path, stroke); 42 | 43 | skPaintSetColor(fill, skColorSetArgb(0x80, 0x00, 0xFF, 0x00)); 44 | const rect2 = new Float32Array([ 45 | 120, 46 | 120, 47 | 520, 48 | 360 49 | ]); 50 | const mask = skMaskfilterNewBlur(enums.NORMAL_SK_BLUR_STYLE, 10.0); 51 | skPaintSetMaskfilter(fill, mask); 52 | skCanvasDrawOval(canvas, rect2.buffer, fill); 53 | 54 | const familyName = "Times New Roman"; 55 | const style = skFontstyleNew(400, 1, enums.UPRIGHT_SK_FONT_STYLE_SLANT); 56 | const typeface = skTypefaceCreateFromNameWithFontStyle(familyName, style); 57 | const text = skPaintNew(); 58 | skPaintSetAntialias(text, true); 59 | skPaintSetColor(text, skColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 60 | skPaintSetTextsize(text, 50.0); 61 | skPaintSetTypeface(text, typeface); 62 | const str = "skiaJS"; 63 | skCanvasDrawText(canvas, str, str.length, 1000.0, 50.0, text); 64 | 65 | const size = new Int32Array([10, 10]); 66 | const shader = skPaintNew(); 67 | const noise = skShaderNewPerlinNoiseTurbulence(0.8, 0.3, 10, 0.383928392, size.buffer); 68 | skPaintSetShader(shader, noise); 69 | const rect3 = new Float32Array([560.0, 100.0, 940.0, 380.0]); 70 | skCanvasDrawRect(canvas, rect3.buffer, shader); 71 | 72 | const s = 200; 73 | const info2 = new Int32Array([ 74 | 0, 0, s, s, enums.GRAY_8_SK_COLORTYPE, enums.OPAQUE_SK_ALPHATYPE 75 | ]); 76 | const bitmap = skPaintNew(); 77 | const img = skBitmapNew(); 78 | skBitmapTryAllocPixels(img, info2.buffer, s); 79 | const pixels = new Uint8Array(s*s); 80 | for (let i = 0; i < s*s; i++) { 81 | if (i%2 == 0 && i%3 == 0) { 82 | pixels[i] = 0xFF; 83 | } else { 84 | pixels[i] = 0x00; 85 | } 86 | } 87 | skBitmapSetPixels(img, pixels.buffer); 88 | skCanvasDrawBitmap(canvas, img, 1000.0, 100.0, bitmap); 89 | 90 | skCanvasSave(canvas); 91 | const stroke2 = skPaintNew(); 92 | skPaintSetColor(stroke2, skColorSetArgb(0xFF, 0x00, 0x00, 0xFF)); 93 | skPaintSetAntialias(stroke2, true); 94 | skPaintSetStyle(stroke2, enums.STROKE_SK_PAINT_STYLE); 95 | skPaintSetStrokeWidth(stroke2, 5.0); 96 | const path2 = skPathNew(); 97 | const svg = "m451.111 451.111h-451.111v-451.111h451.111zm-386.667-64.444h322.222v-322.223h-322.222z"; 98 | skPathParseSvgString(path2, svg); 99 | skCanvasTranslate(canvas, 1000.0, 500.0); 100 | skCanvasScale(canvas, 0.2, 0.2); 101 | skCanvasDrawPath(canvas, path2, stroke2); 102 | skCanvasRestore(canvas); 103 | 104 | skCanvasSave(canvas); 105 | const luma = skColorfilterNewLumaColor(); 106 | const imgfilter = skImagefilterNewColorFilter(luma, null, null); 107 | const imgpaint = skPaintNew(); 108 | skPaintSetImagefilter(imgpaint, imgfilter); 109 | const url = "/Users/akunets/SkiaSharp/images/icon.png"; 110 | const encoded = skDataNewFromFile(url); 111 | const rect4 = new Int32Array([0, 0, 1024, 1024]); 112 | const image2 = skImageNewFromEncoded(encoded, rect4.buffer); 113 | skCanvasScale(canvas, 0.2, 0.2); 114 | skCanvasDrawImage(canvas, image2, 1000.0, 2500.0, imgpaint); 115 | skCanvasRestore(canvas); 116 | 117 | const pointfill = skPaintNew(); 118 | const points = new Float32Array([900.0, 600.0, 1000.0, 700.0]); 119 | skCanvasDrawPoints(canvas, enums.LINES_SK_POINT_MODE, 2, points.buffer, pointfill); 120 | 121 | const rrect = skPaintNew(); 122 | const rounded = skRrectNew(); 123 | const rect6 = new Float32Array([460.0, 500.0, 740.0, 700.0]); 124 | skRrectSetRectXy(rounded, rect6.buffer, 50, 50); 125 | skCanvasDrawRrect(canvas, rounded, rrect); 126 | 127 | skPathDelete(path); 128 | skPaintDelete(stroke); 129 | skPaintDelete(fill); 130 | } 131 | 132 | draw(canvas); 133 | 134 | const image = skSurfaceNewImageSnapshot(surface); 135 | const data = skImageEncode(image); 136 | const l = skDataGetSize(data); 137 | const p = skDataGetData(data); 138 | 139 | const d = getMemory(p, BigInt(l)); 140 | fs.writeFileSync('./res.png', new Int8Array(d)); 141 | -------------------------------------------------------------------------------- /include/c/sk_matrix.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_matrix_DEFINED 11 | #define sk_matrix_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | 18 | SK_C_API bool sk_matrix_try_invert (sk_matrix_t *matrix, sk_matrix_t *result); 19 | SK_C_API void sk_matrix_concat (sk_matrix_t *result, sk_matrix_t *first, sk_matrix_t *second); 20 | SK_C_API void sk_matrix_pre_concat (sk_matrix_t *result, sk_matrix_t *matrix); 21 | SK_C_API void sk_matrix_post_concat (sk_matrix_t *result, sk_matrix_t *matrix); 22 | SK_C_API void sk_matrix_map_rect (sk_matrix_t *matrix, sk_rect_t *dest, sk_rect_t *source); 23 | SK_C_API void sk_matrix_map_points (sk_matrix_t *matrix, sk_point_t *dst, sk_point_t *src, int count); 24 | SK_C_API void sk_matrix_map_vectors (sk_matrix_t *matrix, sk_point_t *dst, sk_point_t *src, int count); 25 | SK_C_API void sk_matrix_map_xy (sk_matrix_t *matrix, float x, float y, sk_point_t* result); 26 | SK_C_API void sk_matrix_map_vector (sk_matrix_t *matrix, float x, float y, sk_point_t* result); 27 | SK_C_API float sk_matrix_map_radius (sk_matrix_t *matrix, float radius); 28 | 29 | 30 | SK_C_API sk_3dview_t* sk_3dview_new (void); 31 | SK_C_API void sk_3dview_destroy (sk_3dview_t* cview); 32 | SK_C_API void sk_3dview_save (sk_3dview_t* cview); 33 | SK_C_API void sk_3dview_restore (sk_3dview_t* cview); 34 | SK_C_API void sk_3dview_translate (sk_3dview_t* cview, float x, float y, float z); 35 | SK_C_API void sk_3dview_rotate_x_degrees (sk_3dview_t* cview, float degrees); 36 | SK_C_API void sk_3dview_rotate_y_degrees (sk_3dview_t* cview, float degrees); 37 | SK_C_API void sk_3dview_rotate_z_degrees (sk_3dview_t* cview, float degrees); 38 | SK_C_API void sk_3dview_rotate_x_radians (sk_3dview_t* cview, float radians); 39 | SK_C_API void sk_3dview_rotate_y_radians (sk_3dview_t* cview, float radians); 40 | SK_C_API void sk_3dview_rotate_z_radians (sk_3dview_t* cview, float radians); 41 | SK_C_API void sk_3dview_get_matrix (sk_3dview_t* cview, sk_matrix_t* cmatrix); 42 | SK_C_API void sk_3dview_apply_to_canvas (sk_3dview_t* cview, sk_canvas_t* ccanvas); 43 | SK_C_API float sk_3dview_dot_with_normal (sk_3dview_t* cview, float dx, float dy, float dz); 44 | 45 | 46 | SK_C_API void sk_matrix44_destroy (sk_matrix44_t* matrix); 47 | SK_C_API sk_matrix44_t* sk_matrix44_new (void); 48 | SK_C_API sk_matrix44_t* sk_matrix44_new_identity (void); 49 | SK_C_API sk_matrix44_t* sk_matrix44_new_copy (const sk_matrix44_t* src); 50 | SK_C_API sk_matrix44_t* sk_matrix44_new_concat (const sk_matrix44_t* a, const sk_matrix44_t* b); 51 | SK_C_API sk_matrix44_t* sk_matrix44_new_matrix (const sk_matrix_t* src); 52 | SK_C_API bool sk_matrix44_equals (sk_matrix44_t* matrix, const sk_matrix44_t* other); 53 | SK_C_API void sk_matrix44_to_matrix (sk_matrix44_t* matrix, sk_matrix_t* dst); 54 | SK_C_API sk_matrix44_type_mask_t sk_matrix44_get_type (sk_matrix44_t* matrix); 55 | SK_C_API void sk_matrix44_set_identity (sk_matrix44_t* matrix); 56 | SK_C_API float sk_matrix44_get (sk_matrix44_t* matrix, int row, int col); 57 | SK_C_API void sk_matrix44_set (sk_matrix44_t* matrix, int row, int col, float value); 58 | SK_C_API void sk_matrix44_as_col_major (sk_matrix44_t* matrix, float* dst); 59 | SK_C_API void sk_matrix44_as_row_major (sk_matrix44_t* matrix, float* dst); 60 | SK_C_API void sk_matrix44_set_col_major (sk_matrix44_t* matrix, float* dst); 61 | SK_C_API void sk_matrix44_set_row_major (sk_matrix44_t* matrix, float* dst); 62 | SK_C_API void sk_matrix44_set_translate (sk_matrix44_t* matrix, float dx, float dy, float dz); 63 | SK_C_API void sk_matrix44_pre_translate (sk_matrix44_t* matrix, float dx, float dy, float dz); 64 | SK_C_API void sk_matrix44_post_translate (sk_matrix44_t* matrix, float dx, float dy, float dz); 65 | SK_C_API void sk_matrix44_set_scale (sk_matrix44_t* matrix, float sx, float sy, float sz); 66 | SK_C_API void sk_matrix44_pre_scale (sk_matrix44_t* matrix, float sx, float sy, float sz); 67 | SK_C_API void sk_matrix44_post_scale (sk_matrix44_t* matrix, float sx, float sy, float sz); 68 | SK_C_API void sk_matrix44_set_rotate_about_degrees (sk_matrix44_t* matrix, float x, float y, float z, float degrees); 69 | SK_C_API void sk_matrix44_set_rotate_about_radians (sk_matrix44_t* matrix, float x, float y, float z, float radians); 70 | SK_C_API void sk_matrix44_set_rotate_about_radians_unit (sk_matrix44_t* matrix, float x, float y, float z, float radians); 71 | SK_C_API void sk_matrix44_set_concat (sk_matrix44_t* matrix, const sk_matrix44_t* a, const sk_matrix44_t* b); 72 | SK_C_API void sk_matrix44_pre_concat (sk_matrix44_t* matrix, const sk_matrix44_t* m); 73 | SK_C_API void sk_matrix44_post_concat (sk_matrix44_t* matrix, const sk_matrix44_t* m); 74 | SK_C_API bool sk_matrix44_invert (sk_matrix44_t* matrix, sk_matrix44_t* inverse); 75 | SK_C_API void sk_matrix44_transpose (sk_matrix44_t* matrix); 76 | SK_C_API void sk_matrix44_map_scalars (sk_matrix44_t* matrix, const float* src, float* dst); 77 | SK_C_API void sk_matrix44_map2 (sk_matrix44_t* matrix, const float* src2, int count, float* dst4); 78 | SK_C_API bool sk_matrix44_preserves_2d_axis_alignment (sk_matrix44_t* matrix, float epsilon); 79 | SK_C_API double sk_matrix44_determinant (sk_matrix44_t* matrix); 80 | 81 | 82 | SK_C_PLUS_PLUS_END_GUARD 83 | 84 | #endif 85 | -------------------------------------------------------------------------------- /include/c/sk_stream.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_stream_DEFINED 11 | #define sk_stream_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_stream_asset_destroy(sk_stream_asset_t* cstream); 18 | 19 | //////////////////////////////////////////////////////////////////////////////// 20 | 21 | SK_C_API sk_stream_filestream_t* sk_filestream_new(const char* path); 22 | SK_C_API void sk_filestream_destroy(sk_stream_filestream_t* cstream); 23 | SK_C_API bool sk_filestream_is_valid(sk_stream_filestream_t* cstream); 24 | 25 | //////////////////////////////////////////////////////////////////////////////// 26 | 27 | SK_C_API sk_stream_memorystream_t* sk_memorystream_new(void); 28 | SK_C_API sk_stream_memorystream_t* sk_memorystream_new_with_length(size_t length); 29 | SK_C_API sk_stream_memorystream_t* sk_memorystream_new_with_data(const void* data, size_t length, bool copyData); 30 | SK_C_API sk_stream_memorystream_t* sk_memorystream_new_with_skdata(sk_data_t* data); 31 | SK_C_API void sk_memorystream_set_memory(sk_stream_memorystream_t* cmemorystream, const void* data, size_t length, bool copyData); 32 | SK_C_API void sk_memorystream_destroy(sk_stream_memorystream_t* cstream); 33 | 34 | //////////////////////////////////////////////////////////////////////////////// 35 | 36 | SK_C_API size_t sk_stream_read(sk_stream_t* cstream, void* buffer, size_t size); 37 | SK_C_API size_t sk_stream_peek(sk_stream_t* cstream, void* buffer, size_t size); 38 | SK_C_API size_t sk_stream_skip(sk_stream_t* cstream, size_t size); 39 | SK_C_API bool sk_stream_is_at_end(sk_stream_t* cstream); 40 | SK_C_API bool sk_stream_read_s8(sk_stream_t* cstream, int8_t* buffer); 41 | SK_C_API bool sk_stream_read_s16(sk_stream_t* cstream, int16_t* buffer); 42 | SK_C_API bool sk_stream_read_s32(sk_stream_t* cstream, int32_t* buffer); 43 | SK_C_API bool sk_stream_read_u8(sk_stream_t* cstream, uint8_t* buffer); 44 | SK_C_API bool sk_stream_read_u16(sk_stream_t* cstream, uint16_t* buffer); 45 | SK_C_API bool sk_stream_read_u32(sk_stream_t* cstream, uint32_t* buffer); 46 | SK_C_API bool sk_stream_read_bool(sk_stream_t* cstream, bool* buffer); 47 | SK_C_API bool sk_stream_rewind(sk_stream_t* cstream); 48 | SK_C_API bool sk_stream_has_position(sk_stream_t* cstream); 49 | SK_C_API size_t sk_stream_get_position(sk_stream_t* cstream); 50 | SK_C_API bool sk_stream_seek(sk_stream_t* cstream, size_t position); 51 | SK_C_API bool sk_stream_move(sk_stream_t* cstream, long offset); 52 | SK_C_API bool sk_stream_has_length(sk_stream_t* cstream); 53 | SK_C_API size_t sk_stream_get_length(sk_stream_t* cstream); 54 | SK_C_API const void* sk_stream_get_memory_base(sk_stream_t* cstream); 55 | SK_C_API sk_stream_t* sk_stream_fork(sk_stream_t* cstream); 56 | SK_C_API sk_stream_t* sk_stream_duplicate(sk_stream_t* cstream); 57 | SK_C_API void sk_stream_destroy(sk_stream_t* cstream); 58 | 59 | //////////////////////////////////////////////////////////////////////////////// 60 | 61 | SK_C_API sk_wstream_filestream_t* sk_filewstream_new(const char* path); 62 | SK_C_API void sk_filewstream_destroy(sk_wstream_filestream_t* cstream); 63 | SK_C_API bool sk_filewstream_is_valid(sk_wstream_filestream_t* cstream); 64 | 65 | SK_C_API sk_wstream_dynamicmemorystream_t* sk_dynamicmemorywstream_new(void); 66 | SK_C_API sk_stream_asset_t* sk_dynamicmemorywstream_detach_as_stream(sk_wstream_dynamicmemorystream_t* cstream); 67 | SK_C_API sk_data_t* sk_dynamicmemorywstream_detach_as_data(sk_wstream_dynamicmemorystream_t* cstream); 68 | SK_C_API void sk_dynamicmemorywstream_copy_to(sk_wstream_dynamicmemorystream_t* cstream, void* data); 69 | SK_C_API bool sk_dynamicmemorywstream_write_to_stream(sk_wstream_dynamicmemorystream_t* cstream, sk_wstream_t* dst); 70 | SK_C_API void sk_dynamicmemorywstream_destroy(sk_wstream_dynamicmemorystream_t* cstream); 71 | 72 | //////////////////////////////////////////////////////////////////////////////// 73 | 74 | SK_C_API bool sk_wstream_write(sk_wstream_t* cstream, const void* buffer, size_t size); 75 | SK_C_API bool sk_wstream_newline(sk_wstream_t* cstream); 76 | SK_C_API void sk_wstream_flush(sk_wstream_t* cstream); 77 | SK_C_API size_t sk_wstream_bytes_written(sk_wstream_t* cstream); 78 | SK_C_API bool sk_wstream_write_8(sk_wstream_t* cstream, uint8_t value); 79 | SK_C_API bool sk_wstream_write_16(sk_wstream_t* cstream, uint16_t value); 80 | SK_C_API bool sk_wstream_write_32(sk_wstream_t* cstream, uint32_t value); 81 | SK_C_API bool sk_wstream_write_text(sk_wstream_t* cstream, const char* value); 82 | SK_C_API bool sk_wstream_write_dec_as_text(sk_wstream_t* cstream, int32_t value); 83 | SK_C_API bool sk_wstream_write_bigdec_as_text(sk_wstream_t* cstream, int64_t value, int minDigits); 84 | SK_C_API bool sk_wstream_write_hex_as_text(sk_wstream_t* cstream, uint32_t value, int minDigits); 85 | SK_C_API bool sk_wstream_write_scalar_as_text(sk_wstream_t* cstream, float value); 86 | SK_C_API bool sk_wstream_write_bool(sk_wstream_t* cstream, bool value); 87 | SK_C_API bool sk_wstream_write_scalar(sk_wstream_t* cstream, float value); 88 | SK_C_API bool sk_wstream_write_packed_uint(sk_wstream_t* cstream, size_t value); 89 | SK_C_API bool sk_wstream_write_stream(sk_wstream_t* cstream, sk_stream_t* input, size_t length); 90 | SK_C_API int sk_wstream_get_size_of_packed_uint(size_t value); 91 | 92 | SK_C_PLUS_PLUS_END_GUARD 93 | 94 | #endif 95 | -------------------------------------------------------------------------------- /examples/part.js: -------------------------------------------------------------------------------- 1 | const { performance } = require('perf_hooks'); 2 | const skia = require('../generated/interface'); 3 | const glfw = require('glfw-n-api'); 4 | 5 | Object.assign(global, glfw); 6 | Object.assign(global, skia); 7 | 8 | function error_callback(error, description) { 9 | console.log(arguments); 10 | } 11 | 12 | function key_callback(window, key, scancode, action, mods) { 13 | console.log(window, key, scancode, action, mods); 14 | if (key == 256 && action == 1) { 15 | glfwSetWindowShouldClose(window, GL_TRUE); 16 | } 17 | } 18 | function mousecallback(win, x, y) { 19 | try { 20 | mx = x; 21 | my = y; 22 | man = true; 23 | } catch(e) { 24 | console.log(e) 25 | } 26 | 27 | } 28 | 29 | 30 | const kWidth = 1280; 31 | const kHeight = 720; 32 | 33 | let window; 34 | glfwSetErrorCallback(error_callback); 35 | if (!glfwInit()) { 36 | process.exit(1); 37 | } 38 | 39 | glfwWindowHint(0x00022002, 3); 40 | glfwWindowHint(0x00022003, 2); 41 | glfwWindowHint(0x00022006, GL_TRUE); 42 | glfwWindowHint(0x00022008, 0x00032001); 43 | //(uncomment to enable correct color spaces) glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE); 44 | glfwWindowHint(0x00021006, 0); 45 | //glfwWindowHint(GLFW_ALPHA_BITS, 0); 46 | glfwWindowHint(0x00021005, 0); 47 | 48 | window = glfwCreateWindow(kWidth, kHeight, "Simple example", null, null); 49 | if (!window) { 50 | glfwTerminate(); 51 | process.exit(1); 52 | } 53 | glfwMakeContextCurrent(window); 54 | //(uncomment to enable correct color spaces) glEnable(GL_FRAMEBUFFER_SRGB); 55 | let width = new Int32Array([0]); 56 | let height = new Int32Array([0]); 57 | const widthP = getAddress(width.buffer); 58 | const heightP = getAddress(height.buffer); 59 | 60 | glfwGetFramebufferSize(window, widthP, heightP); 61 | let devicePixelRatio = width[0] / kWidth; 62 | 63 | const glInterface = grGlinterfaceCreateNativeInterface(); 64 | const context = grContextMakeGl(glInterface); 65 | const glInfo = new Int32Array([0, GL_RGBA8]); 66 | const target = grBackendrendertargetNewGl(width[0], height[0], 0, 0, glInfo.buffer); 67 | const surface = skSurfaceNewBackendRenderTarget(context, target, enums.BOTTOM_LEFT_GR_SURFACE_ORIGIN, enums.RGBA_8888_SK_COLORTYPE, null, null); 68 | 69 | glfwSwapInterval(1); 70 | glfwSetKeyCallback(window, key_callback); 71 | glfwSetCursorPosCallback(window, mousecallback); 72 | const canvas = skSurfaceGetCanvas(surface); 73 | 74 | 75 | var NUM_PARTICLES = ( ( ROWS = 100 ) * ( COLS = 300 ) ), 76 | THICKNESS = Math.pow( 80, 2 ), 77 | SPACING = 3, 78 | MARGIN = 100, 79 | COLOR = 220, 80 | DRAG = 0.95, 81 | EASE = 0.25, 82 | 83 | /* 84 | 85 | used for sine approximation, but Math.sin in Chrome is still fast enough :)http://jsperf.com/math-sin-vs-sine-approximation 86 | 87 | B = 4 / Math.PI, 88 | C = -4 / Math.pow( Math.PI, 2 ), 89 | P = 0.225, 90 | 91 | */ 92 | 93 | container, 94 | particle, 95 | mouse, 96 | stats, 97 | list, 98 | ctx, 99 | tog, 100 | man, 101 | dx, dy, 102 | mx, my, 103 | d, t, f, 104 | a, b, 105 | i, n, 106 | w, h, 107 | p, s, 108 | r, c 109 | ; 110 | 111 | particle = { 112 | vx: 0, 113 | vy: 0, 114 | x: 0, 115 | y: 0 116 | }; 117 | 118 | function init() { 119 | 120 | man = false; 121 | tog = true; 122 | 123 | list = []; 124 | 125 | w = COLS * SPACING + MARGIN * 2; 126 | h = ROWS * SPACING + MARGIN * 2; 127 | 128 | for ( i = 0; i < NUM_PARTICLES; i++ ) { 129 | 130 | p = Object.create( particle ); 131 | p.x = p.ox = MARGIN + SPACING * ( i % COLS ); 132 | p.y = p.oy = MARGIN + SPACING * Math.floor( i / COLS ); 133 | 134 | list[i] = p; 135 | } 136 | 137 | 138 | } 139 | init() 140 | 141 | 142 | function draw(){ 143 | skCanvasSave(canvas); 144 | skCanvasScale(canvas, devicePixelRatio, devicePixelRatio); 145 | 146 | 147 | if ( tog = !tog ) { 148 | 149 | if ( !man ) { 150 | 151 | t = +new Date() * 0.001; 152 | mx = w * 0.5 + ( Math.cos( t * 2.1 ) * Math.cos( t * 0.9 ) * w * 0.45 ); 153 | my = h * 0.5 + ( Math.sin( t * 3.2 ) * Math.tan( Math.sin( t * 0.8 ) ) * h * 0.45 ); 154 | } 155 | 156 | for ( i = 0; i < NUM_PARTICLES; i++ ) { 157 | 158 | p = list[i]; 159 | 160 | d = ( dx = mx - p.x ) * dx + ( dy = my - p.y ) * dy; 161 | f = -THICKNESS / d; 162 | 163 | if ( d < THICKNESS ) { 164 | t = Math.atan2( dy, dx ); 165 | p.vx += f * Math.cos(t); 166 | p.vy += f * Math.sin(t); 167 | } 168 | 169 | p.x += ( p.vx *= DRAG ) + (p.ox - p.x) * EASE; 170 | p.y += ( p.vy *= DRAG ) + (p.oy - p.y) * EASE; 171 | 172 | } 173 | 174 | } 175 | const fill = skPaintNew(); 176 | skPaintSetColor(fill, skColorSetArgb(0xFF, 0x00, 0x00, 0x00)); 177 | skCanvasDrawPaint(canvas, fill); 178 | 179 | const info2 = new Int32Array([ 180 | 0, 0, w, h, enums.RGBA_8888_SK_COLORTYPE, enums.OPAQUE_SK_ALPHATYPE 181 | ]); 182 | const bitmap = skPaintNew(); 183 | const img = skBitmapNew(); 184 | skBitmapTryAllocPixels(img, info2.buffer, w*4); 185 | const pixels = new Uint8Array(w*h*4); 186 | for ( i = 0; i < NUM_PARTICLES; i++ ) { 187 | p = list[i]; 188 | pixels[n = ( ~~p.x + ( ~~p.y * w ) ) * 4] = pixels[n+1] = pixels[n+2] = COLOR, pixels[n+3] = 255; 189 | } 190 | skBitmapSetPixels(img, pixels.buffer); 191 | skCanvasDrawBitmap(canvas, img, 0, 0, bitmap); 192 | 193 | 194 | 195 | skCanvasRestore(canvas); 196 | } 197 | 198 | let frames = 0; 199 | let t0 = 0; 200 | let previous = glfwGetTime(); 201 | function drawLoop() { 202 | if (!glfwWindowShouldClose(window)) { 203 | setTimeout(() => { 204 | const t = performance.now(); 205 | if (t - t0 > 1000.0 || frames === 0) { 206 | const fps = Math.floor((frames / (t - t0)) * 1e3); 207 | glfwSetWindowTitle(window, `FPS: ${fps}`); 208 | t0 = t; 209 | frames = 0; 210 | } 211 | frames++; 212 | 213 | drawLoop(); 214 | }, 0); 215 | } else { 216 | glfwDestroyWindow(window); 217 | glfwTerminate(); 218 | process.exit(0); 219 | } 220 | 221 | let now = glfwGetTime(); 222 | let delta = now - previous; 223 | previous = now; 224 | 225 | draw(canvas, devicePixelRatio, now); 226 | 227 | grContextFlush(context); 228 | 229 | glfwSwapBuffers(window); 230 | 231 | glfwPollEvents(); 232 | } 233 | drawLoop(); 234 | -------------------------------------------------------------------------------- /include/c/sk_paint.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_paint_DEFINED 11 | #define sk_paint_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_paint_t* sk_paint_new(void); 18 | SK_C_API sk_paint_t* sk_paint_clone(sk_paint_t*); 19 | SK_C_API void sk_paint_delete(sk_paint_t*); 20 | SK_C_API void sk_paint_reset(sk_paint_t*); 21 | SK_C_API bool sk_paint_is_antialias(const sk_paint_t*); 22 | SK_C_API void sk_paint_set_antialias(sk_paint_t*, bool); 23 | SK_C_API sk_color_t sk_paint_get_color(const sk_paint_t*); 24 | SK_C_API void sk_paint_set_color(sk_paint_t*, sk_color_t); 25 | SK_C_API sk_paint_style_t sk_paint_get_style(const sk_paint_t*); 26 | SK_C_API void sk_paint_set_style(sk_paint_t*, sk_paint_style_t); 27 | SK_C_API float sk_paint_get_stroke_width(const sk_paint_t*); 28 | SK_C_API void sk_paint_set_stroke_width(sk_paint_t*, float width); 29 | SK_C_API float sk_paint_get_stroke_miter(const sk_paint_t*); 30 | SK_C_API void sk_paint_set_stroke_miter(sk_paint_t*, float miter); 31 | SK_C_API sk_stroke_cap_t sk_paint_get_stroke_cap(const sk_paint_t*); 32 | SK_C_API void sk_paint_set_stroke_cap(sk_paint_t*, sk_stroke_cap_t); 33 | SK_C_API sk_stroke_join_t sk_paint_get_stroke_join(const sk_paint_t*); 34 | SK_C_API void sk_paint_set_stroke_join(sk_paint_t*, sk_stroke_join_t); 35 | SK_C_API void sk_paint_set_shader(sk_paint_t*, sk_shader_t*); 36 | SK_C_API void sk_paint_set_maskfilter(sk_paint_t*, sk_maskfilter_t*); 37 | SK_C_API void sk_paint_set_blendmode(sk_paint_t*, sk_blendmode_t); 38 | SK_C_API bool sk_paint_is_dither(const sk_paint_t*); 39 | SK_C_API void sk_paint_set_dither(sk_paint_t*, bool); 40 | SK_C_API bool sk_paint_is_verticaltext(const sk_paint_t*); 41 | SK_C_API void sk_paint_set_verticaltext(sk_paint_t*, bool); 42 | SK_C_API sk_shader_t* sk_paint_get_shader(sk_paint_t*); 43 | SK_C_API sk_maskfilter_t* sk_paint_get_maskfilter(sk_paint_t*); 44 | SK_C_API void sk_paint_set_colorfilter(sk_paint_t*, sk_colorfilter_t*); 45 | SK_C_API sk_colorfilter_t* sk_paint_get_colorfilter(sk_paint_t*); 46 | SK_C_API void sk_paint_set_imagefilter(sk_paint_t*, sk_imagefilter_t*); 47 | SK_C_API sk_imagefilter_t* sk_paint_get_imagefilter(sk_paint_t*); 48 | SK_C_API sk_blendmode_t sk_paint_get_blendmode(sk_paint_t*); 49 | SK_C_API void sk_paint_set_filter_quality(sk_paint_t*, sk_filter_quality_t); 50 | SK_C_API sk_filter_quality_t sk_paint_get_filter_quality(sk_paint_t *); 51 | SK_C_API sk_typeface_t* sk_paint_get_typeface(sk_paint_t*); 52 | SK_C_API void sk_paint_set_typeface(sk_paint_t*, sk_typeface_t*); 53 | SK_C_API float sk_paint_get_textsize(sk_paint_t*); 54 | SK_C_API void sk_paint_set_textsize(sk_paint_t*, float); 55 | SK_C_API sk_text_align_t sk_paint_get_text_align(const sk_paint_t*); 56 | SK_C_API void sk_paint_set_text_align(sk_paint_t*, sk_text_align_t); 57 | SK_C_API sk_text_encoding_t sk_paint_get_text_encoding(const sk_paint_t*); 58 | SK_C_API void sk_paint_set_text_encoding(sk_paint_t*, sk_text_encoding_t); 59 | SK_C_API float sk_paint_get_text_scale_x(const sk_paint_t* cpaint); 60 | SK_C_API void sk_paint_set_text_scale_x(sk_paint_t* cpaint, float scale); 61 | SK_C_API float sk_paint_get_text_skew_x(const sk_paint_t* cpaint); 62 | SK_C_API void sk_paint_set_text_skew_x(sk_paint_t* cpaint, float skew); 63 | SK_C_API size_t sk_paint_break_text(const sk_paint_t* cpaint, const void* text, size_t length, float maxWidth, float* measuredWidth); 64 | SK_C_API float sk_paint_measure_text(const sk_paint_t* cpaint, const void* text, size_t length, sk_rect_t* cbounds); 65 | SK_C_API sk_path_t* sk_paint_get_text_path(sk_paint_t* cpaint, const void* text, size_t length, float x, float y); 66 | SK_C_API sk_path_t* sk_paint_get_pos_text_path(sk_paint_t* cpaint, const void* text, size_t length, const sk_point_t pos[]); 67 | SK_C_API float sk_paint_get_fontmetrics(sk_paint_t* cpaint, sk_fontmetrics_t* cfontmetrics, float scale); 68 | SK_C_API sk_path_effect_t* sk_paint_get_path_effect(sk_paint_t* cpaint); 69 | SK_C_API void sk_paint_set_path_effect(sk_paint_t* cpaint, sk_path_effect_t* effect); 70 | SK_C_API bool sk_paint_is_linear_text(const sk_paint_t*); 71 | SK_C_API void sk_paint_set_linear_text(sk_paint_t*, bool); 72 | SK_C_API bool sk_paint_is_subpixel_text(const sk_paint_t*); 73 | SK_C_API void sk_paint_set_subpixel_text(sk_paint_t*, bool); 74 | SK_C_API bool sk_paint_is_lcd_render_text(const sk_paint_t*); 75 | SK_C_API void sk_paint_set_lcd_render_text(sk_paint_t*, bool); 76 | SK_C_API bool sk_paint_is_embedded_bitmap_text(const sk_paint_t*); 77 | SK_C_API void sk_paint_set_embedded_bitmap_text(sk_paint_t*, bool); 78 | SK_C_API sk_paint_hinting_t sk_paint_get_hinting(const sk_paint_t*); 79 | SK_C_API void sk_paint_set_hinting(sk_paint_t*, sk_paint_hinting_t); 80 | SK_C_API bool sk_paint_is_autohinted(const sk_paint_t*); 81 | SK_C_API void sk_paint_set_autohinted(sk_paint_t*, bool); 82 | SK_C_API bool sk_paint_is_fake_bold_text(const sk_paint_t*); 83 | SK_C_API void sk_paint_set_fake_bold_text(sk_paint_t*, bool); 84 | SK_C_API bool sk_paint_is_dev_kern_text(const sk_paint_t*); 85 | SK_C_API void sk_paint_set_dev_kern_text(sk_paint_t*, bool); 86 | SK_C_API bool sk_paint_get_fill_path(const sk_paint_t*, const sk_path_t* src, sk_path_t* dst, const sk_rect_t* cullRect, float resScale); 87 | SK_C_API int sk_paint_text_to_glyphs(const sk_paint_t* cpaint, const void* text, size_t byteLength, uint16_t* glyphs); 88 | SK_C_API bool sk_paint_contains_text(const sk_paint_t* cpaint, const void* text, size_t byteLength); 89 | SK_C_API int sk_paint_count_text(const sk_paint_t* cpaint, const void* text, size_t byteLength); 90 | SK_C_API int sk_paint_get_text_widths(const sk_paint_t* cpaint, const void* text, size_t byteLength, float* widths, sk_rect_t* bounds); 91 | SK_C_API int sk_paint_get_text_intercepts(const sk_paint_t* cpaint, const void* text, size_t byteLength, float x, float y, const float bounds[2], float* intervals); 92 | SK_C_API int sk_paint_get_pos_text_intercepts(const sk_paint_t* cpaint, const void* text, size_t byteLength, sk_point_t* pos, const float bounds[2], float* intervals); 93 | SK_C_API int sk_paint_get_pos_text_h_intercepts(const sk_paint_t* cpaint, const void* text, size_t byteLength, float* xpos, float y, const float bounds[2], float* intervals); 94 | SK_C_API int sk_paint_get_pos_text_blob_intercepts(const sk_paint_t* cpaint, sk_textblob_t* blob, const float bounds[2], float* intervals); 95 | 96 | SK_C_PLUS_PLUS_END_GUARD 97 | 98 | #endif 99 | -------------------------------------------------------------------------------- /include/c/sk_imagefilter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_imagefilter_DEFINED 11 | #define sk_imagefilter_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API sk_imagefilter_croprect_t* sk_imagefilter_croprect_new(void); 18 | SK_C_API sk_imagefilter_croprect_t* sk_imagefilter_croprect_new_with_rect(const sk_rect_t* rect, uint32_t flags); 19 | SK_C_API void sk_imagefilter_croprect_destructor(sk_imagefilter_croprect_t* cropRect); 20 | SK_C_API void sk_imagefilter_croprect_get_rect(sk_imagefilter_croprect_t* cropRect, sk_rect_t* rect); 21 | SK_C_API uint32_t sk_imagefilter_croprect_get_flags(sk_imagefilter_croprect_t* cropRect); 22 | SK_C_API void sk_imagefilter_unref(sk_imagefilter_t*); 23 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_matrix( 24 | const sk_matrix_t* matrix, 25 | sk_filter_quality_t quality, 26 | sk_imagefilter_t* input /*NULL*/); 27 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_alpha_threshold( 28 | const sk_region_t* region, 29 | float innerThreshold, 30 | float outerThreshold, 31 | sk_imagefilter_t* input /*NULL*/); 32 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_blur( 33 | float sigmaX, 34 | float sigmaY, 35 | sk_imagefilter_t* input /*NULL*/, 36 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 37 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_color_filter( 38 | sk_colorfilter_t* cf, 39 | sk_imagefilter_t* input /*NULL*/, 40 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 41 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_compose( 42 | sk_imagefilter_t* outer, 43 | sk_imagefilter_t* inner); 44 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_displacement_map_effect( 45 | sk_displacement_map_effect_channel_selector_type_t xChannelSelector, 46 | sk_displacement_map_effect_channel_selector_type_t yChannelSelector, 47 | float scale, 48 | sk_imagefilter_t* displacement, 49 | sk_imagefilter_t* color /*NULL*/, 50 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 51 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_drop_shadow( 52 | float dx, 53 | float dy, 54 | float sigmaX, 55 | float sigmaY, 56 | sk_color_t color, 57 | sk_drop_shadow_image_filter_shadow_mode_t shadowMode, 58 | sk_imagefilter_t* input /*NULL*/, 59 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 60 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_distant_lit_diffuse( 61 | const sk_point3_t* direction, 62 | sk_color_t lightColor, 63 | float surfaceScale, 64 | float kd, 65 | sk_imagefilter_t* input /*NULL*/, 66 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 67 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_point_lit_diffuse( 68 | const sk_point3_t* location, 69 | sk_color_t lightColor, 70 | float surfaceScale, 71 | float kd, 72 | sk_imagefilter_t* input /*NULL*/, 73 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 74 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_spot_lit_diffuse( 75 | const sk_point3_t* location, 76 | const sk_point3_t* target, 77 | float specularExponent, 78 | float cutoffAngle, 79 | sk_color_t lightColor, 80 | float surfaceScale, 81 | float kd, 82 | sk_imagefilter_t* input /*NULL*/, 83 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 84 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_distant_lit_specular( 85 | const sk_point3_t* direction, 86 | sk_color_t lightColor, 87 | float surfaceScale, 88 | float ks, 89 | float shininess, 90 | sk_imagefilter_t* input /*NULL*/, 91 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 92 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_point_lit_specular( 93 | const sk_point3_t* location, 94 | sk_color_t lightColor, 95 | float surfaceScale, 96 | float ks, 97 | float shininess, 98 | sk_imagefilter_t* input /*NULL*/, 99 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 100 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_spot_lit_specular( 101 | const sk_point3_t* location, 102 | const sk_point3_t* target, 103 | float specularExponent, 104 | float cutoffAngle, 105 | sk_color_t lightColor, 106 | float surfaceScale, 107 | float ks, 108 | float shininess, 109 | sk_imagefilter_t* input /*NULL*/, 110 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 111 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_magnifier( 112 | const sk_rect_t* src, 113 | float inset, 114 | sk_imagefilter_t* input, /*NULL*/ 115 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 116 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_matrix_convolution( 117 | const sk_isize_t* kernelSize, 118 | const float kernel[], 119 | float gain, 120 | float bias, 121 | const sk_ipoint_t* kernelOffset, 122 | sk_matrix_convolution_tilemode_t tileMode, 123 | bool convolveAlpha, 124 | sk_imagefilter_t* input /*NULL*/, 125 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 126 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_merge( 127 | sk_imagefilter_t* filters[], 128 | int count, 129 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 130 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_dilate( 131 | int radiusX, 132 | int radiusY, 133 | sk_imagefilter_t* input /*NULL*/, 134 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 135 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_erode( 136 | int radiusX, 137 | int radiusY, 138 | sk_imagefilter_t* input /*NULL*/, 139 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 140 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_offset( 141 | float dx, 142 | float dy, 143 | sk_imagefilter_t* input /*NULL*/, 144 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 145 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_picture( 146 | sk_picture_t* picture); 147 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_picture_with_croprect( 148 | sk_picture_t* picture, 149 | const sk_rect_t* cropRect); 150 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_tile( 151 | const sk_rect_t* src, 152 | const sk_rect_t* dst, 153 | sk_imagefilter_t* input); 154 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_xfermode( 155 | sk_blendmode_t mode, 156 | sk_imagefilter_t* background, 157 | sk_imagefilter_t* foreground /*NULL*/, 158 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 159 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_arithmetic( 160 | float k1, float k2, float k3, float k4, 161 | bool enforcePMColor, 162 | sk_imagefilter_t* background, 163 | sk_imagefilter_t* foreground /*NULL*/, 164 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 165 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_image_source( 166 | sk_image_t* image, 167 | const sk_rect_t* srcRect, 168 | const sk_rect_t* dstRect, 169 | sk_filter_quality_t filterQuality); 170 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_image_source_default( 171 | sk_image_t* image); 172 | SK_C_API sk_imagefilter_t* sk_imagefilter_new_paint( 173 | const sk_paint_t* paint, 174 | const sk_imagefilter_croprect_t* cropRect /*NULL*/); 175 | 176 | SK_C_PLUS_PLUS_END_GUARD 177 | 178 | #endif 179 | -------------------------------------------------------------------------------- /include/c/sk_canvas.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_canvas_DEFINED 11 | #define sk_canvas_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | SK_C_API void sk_canvas_destroy(sk_canvas_t*); 18 | SK_C_API int sk_canvas_save(sk_canvas_t*); 19 | SK_C_API int sk_canvas_save_layer(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*); 20 | SK_C_API void sk_canvas_restore(sk_canvas_t*); 21 | SK_C_API void sk_canvas_translate(sk_canvas_t*, float dx, float dy); 22 | SK_C_API void sk_canvas_scale(sk_canvas_t*, float sx, float sy); 23 | SK_C_API void sk_canvas_rotate_degrees(sk_canvas_t*, float degrees); 24 | SK_C_API void sk_canvas_rotate_radians(sk_canvas_t*, float radians); 25 | SK_C_API void sk_canvas_skew(sk_canvas_t*, float sx, float sy); 26 | SK_C_API void sk_canvas_concat(sk_canvas_t*, const sk_matrix_t*); 27 | SK_C_API bool sk_canvas_quick_reject(sk_canvas_t*, const sk_rect_t*); 28 | SK_C_API void sk_canvas_clip_region(sk_canvas_t* canvas, const sk_region_t* region, sk_clipop_t op); 29 | SK_C_API void sk_canvas_draw_paint(sk_canvas_t*, const sk_paint_t*); 30 | SK_C_API void sk_canvas_draw_rect(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*); 31 | SK_C_API void sk_canvas_draw_rrect(sk_canvas_t*, const sk_rrect_t*, const sk_paint_t*); 32 | SK_C_API void sk_canvas_draw_region(sk_canvas_t*, const sk_region_t*, const sk_paint_t*); 33 | SK_C_API void sk_canvas_draw_circle(sk_canvas_t*, float cx, float cy, float rad, const sk_paint_t*); 34 | SK_C_API void sk_canvas_draw_oval(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*); 35 | SK_C_API void sk_canvas_draw_path(sk_canvas_t*, const sk_path_t*, const sk_paint_t*); 36 | SK_C_API void sk_canvas_draw_image(sk_canvas_t*, const sk_image_t*, float x, float y, const sk_paint_t*); 37 | SK_C_API void sk_canvas_draw_image_rect(sk_canvas_t*, const sk_image_t*, const sk_rect_t* src, const sk_rect_t* dst, const sk_paint_t*); 38 | SK_C_API void sk_canvas_draw_picture(sk_canvas_t*, const sk_picture_t*, const sk_matrix_t*, const sk_paint_t*); 39 | SK_C_API void sk_canvas_draw_drawable(sk_canvas_t*, sk_drawable_t*, const sk_matrix_t*); 40 | SK_C_API void sk_canvas_clear(sk_canvas_t*, sk_color_t); 41 | SK_C_API void sk_canvas_discard(sk_canvas_t*); 42 | SK_C_API int sk_canvas_get_save_count(sk_canvas_t*); 43 | SK_C_API void sk_canvas_restore_to_count(sk_canvas_t*, int saveCount); 44 | SK_C_API void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_blendmode_t mode); 45 | SK_C_API void sk_canvas_draw_points(sk_canvas_t*, sk_point_mode_t, size_t, const sk_point_t[], const sk_paint_t*); 46 | SK_C_API void sk_canvas_draw_point(sk_canvas_t*, float, float, const sk_paint_t*); 47 | SK_C_API void sk_canvas_draw_line(sk_canvas_t* ccanvas, float x0, float y0, float x1, float y1, sk_paint_t* cpaint); 48 | SK_C_API void sk_canvas_draw_text (sk_canvas_t*, const char* text, size_t byteLength, float x, float y, const sk_paint_t* paint); 49 | SK_C_API void sk_canvas_draw_pos_text (sk_canvas_t*, const char* text, size_t byteLength, const sk_point_t[], const sk_paint_t* paint); 50 | SK_C_API void sk_canvas_draw_text_on_path (sk_canvas_t*, const char* text, size_t byteLength, const sk_path_t*path, float hOffset, float vOffset, const sk_paint_t* paint); 51 | SK_C_API void sk_canvas_draw_text_blob (sk_canvas_t*, sk_textblob_t* text, float x, float y, const sk_paint_t* paint); 52 | SK_C_API void sk_canvas_draw_bitmap(sk_canvas_t* ccanvas, const sk_bitmap_t* bitmap, float left, float top, const sk_paint_t* paint); 53 | SK_C_API void sk_canvas_draw_bitmap_rect(sk_canvas_t* ccanvas, const sk_bitmap_t* bitmap, const sk_rect_t* src, const sk_rect_t* dst, const sk_paint_t* paint); 54 | SK_C_API void sk_canvas_reset_matrix(sk_canvas_t* ccanvas); 55 | SK_C_API void sk_canvas_set_matrix(sk_canvas_t* ccanvas, const sk_matrix_t* matrix); 56 | SK_C_API void sk_canvas_get_total_matrix(sk_canvas_t* ccanvas, sk_matrix_t* matrix); 57 | SK_C_API void sk_canvas_draw_round_rect(sk_canvas_t*, const sk_rect_t*, float rx, float ry, const sk_paint_t*); 58 | SK_C_API void sk_canvas_clip_rect_with_operation(sk_canvas_t* t, const sk_rect_t* crect, sk_clipop_t op, bool doAA); 59 | SK_C_API void sk_canvas_clip_path_with_operation(sk_canvas_t* t, const sk_path_t* crect, sk_clipop_t op, bool doAA); 60 | SK_C_API void sk_canvas_clip_rrect_with_operation(sk_canvas_t* t, const sk_rrect_t* crect, sk_clipop_t op, bool doAA); 61 | SK_C_API bool sk_canvas_get_local_clip_bounds(sk_canvas_t* t, sk_rect_t* cbounds); 62 | SK_C_API bool sk_canvas_get_device_clip_bounds(sk_canvas_t* t, sk_irect_t* cbounds); 63 | SK_C_API void sk_canvas_flush(sk_canvas_t* ccanvas); 64 | SK_C_API sk_canvas_t* sk_canvas_new_from_bitmap(const sk_bitmap_t* bitmap); 65 | SK_C_API void sk_canvas_draw_annotation(sk_canvas_t* t, const sk_rect_t* rect, const char* key, sk_data_t* value); 66 | SK_C_API void sk_canvas_draw_url_annotation(sk_canvas_t* t, const sk_rect_t* rect, sk_data_t* value); 67 | SK_C_API void sk_canvas_draw_named_destination_annotation(sk_canvas_t* t, const sk_point_t* point, sk_data_t* value); 68 | SK_C_API void sk_canvas_draw_link_destination_annotation(sk_canvas_t* t, const sk_rect_t* rect, sk_data_t* value); 69 | SK_C_API void sk_canvas_draw_bitmap_lattice(sk_canvas_t* t, const sk_bitmap_t* bitmap, const sk_lattice_t* lattice, const sk_rect_t* dst, const sk_paint_t* paint); 70 | SK_C_API void sk_canvas_draw_image_lattice(sk_canvas_t* t, const sk_image_t* image, const sk_lattice_t* lattice, const sk_rect_t* dst, const sk_paint_t* paint); 71 | SK_C_API void sk_canvas_draw_bitmap_nine(sk_canvas_t* t, const sk_bitmap_t* bitmap, const sk_irect_t* center, const sk_rect_t* dst, const sk_paint_t* paint); 72 | SK_C_API void sk_canvas_draw_image_nine(sk_canvas_t* t, const sk_image_t* image, const sk_irect_t* center, const sk_rect_t* dst, const sk_paint_t* paint); 73 | SK_C_API void sk_canvas_draw_vertices(sk_canvas_t* ccanvas, const sk_vertices_t* vertices, sk_blendmode_t mode, const sk_paint_t* paint); 74 | SK_C_API void sk_canvas_draw_arc(sk_canvas_t* ccanvas, const sk_rect_t* oval, float startAngle, float sweepAngle, bool useCenter, const sk_paint_t* paint); 75 | SK_C_API void sk_canvas_draw_drrect(sk_canvas_t* ccanvas, const sk_rrect_t* outer, const sk_rrect_t* inner, const sk_paint_t* paint); 76 | SK_C_API void sk_canvas_draw_atlas(sk_canvas_t* ccanvas, const sk_image_t* atlas, const sk_rsxform_t* xform, const sk_rect_t* tex, const sk_color_t* colors, int count, sk_blendmode_t mode, const sk_rect_t* cullRect, const sk_paint_t* paint); 77 | SK_C_API void sk_canvas_draw_patch(sk_canvas_t* ccanvas, const sk_point_t* cubics, const sk_color_t* colors, const sk_point_t* texCoords, sk_blendmode_t mode, const sk_paint_t* paint); 78 | SK_C_API bool sk_canvas_is_clip_empty(sk_canvas_t* ccanvas); 79 | SK_C_API bool sk_canvas_is_clip_rect(sk_canvas_t* ccanvas); 80 | 81 | SK_C_API sk_nodraw_canvas_t* sk_nodraw_canvas_new(int width, int height); 82 | SK_C_API void sk_nodraw_canvas_destroy(sk_nodraw_canvas_t*); 83 | 84 | SK_C_API sk_nway_canvas_t* sk_nway_canvas_new(int width, int height); 85 | SK_C_API void sk_nway_canvas_destroy(sk_nway_canvas_t*); 86 | SK_C_API void sk_nway_canvas_add_canvas(sk_nway_canvas_t*, sk_canvas_t* canvas); 87 | SK_C_API void sk_nway_canvas_remove_canvas(sk_nway_canvas_t*, sk_canvas_t* canvas); 88 | SK_C_API void sk_nway_canvas_remove_all(sk_nway_canvas_t*); 89 | 90 | SK_C_API sk_overdraw_canvas_t* sk_overdraw_canvas_new(sk_canvas_t* canvas); 91 | SK_C_API void sk_overdraw_canvas_destroy(sk_overdraw_canvas_t* canvas); 92 | 93 | SK_C_PLUS_PLUS_END_GUARD 94 | 95 | #endif 96 | -------------------------------------------------------------------------------- /include/c/sk_path.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_path_DEFINED 11 | #define sk_path_DEFINED 12 | 13 | #include "sk_types.h" 14 | 15 | SK_C_PLUS_PLUS_BEGIN_GUARD 16 | 17 | /* Path */ 18 | SK_C_API sk_path_t* sk_path_new(void); 19 | SK_C_API void sk_path_delete(sk_path_t*); 20 | SK_C_API void sk_path_move_to(sk_path_t*, float x, float y); 21 | SK_C_API void sk_path_line_to(sk_path_t*, float x, float y); 22 | SK_C_API void sk_path_quad_to(sk_path_t*, float x0, float y0, float x1, float y1); 23 | SK_C_API void sk_path_conic_to(sk_path_t*, float x0, float y0, float x1, float y1, float w); 24 | SK_C_API void sk_path_cubic_to(sk_path_t*, float x0, float y0, float x1, float y1, float x2, float y2); 25 | SK_C_API void sk_path_arc_to(sk_path_t*, float rx, float ry, float xAxisRotate, sk_path_arc_size_t largeArc, sk_path_direction_t sweep, float x, float y); 26 | SK_C_API void sk_path_rarc_to(sk_path_t*, float rx, float ry, float xAxisRotate, sk_path_arc_size_t largeArc, sk_path_direction_t sweep, float x, float y); 27 | SK_C_API void sk_path_arc_to_with_oval(sk_path_t*, const sk_rect_t* oval, float startAngle, float sweepAngle, bool forceMoveTo); 28 | SK_C_API void sk_path_arc_to_with_points(sk_path_t*, float x1, float y1, float x2, float y2, float radius); 29 | SK_C_API void sk_path_close(sk_path_t*); 30 | SK_C_API void sk_path_add_rect(sk_path_t*, const sk_rect_t*, sk_path_direction_t); 31 | SK_C_API void sk_path_add_rrect(sk_path_t*, const sk_rrect_t*, sk_path_direction_t); 32 | SK_C_API void sk_path_add_rrect_start(sk_path_t*, const sk_rrect_t*, sk_path_direction_t, uint32_t); 33 | SK_C_API void sk_path_add_rounded_rect(sk_path_t*, const sk_rect_t*, float, float, sk_path_direction_t); 34 | SK_C_API void sk_path_add_oval(sk_path_t*, const sk_rect_t*, sk_path_direction_t); 35 | SK_C_API void sk_path_add_circle(sk_path_t*, float x, float y, float radius, sk_path_direction_t dir); 36 | SK_C_API void sk_path_get_bounds(const sk_path_t*, sk_rect_t*); 37 | SK_C_API void sk_path_compute_tight_bounds(const sk_path_t*, sk_rect_t*); 38 | SK_C_API void sk_path_rmove_to(sk_path_t*, float dx, float dy); 39 | SK_C_API void sk_path_rline_to(sk_path_t*, float dx, float yd); 40 | SK_C_API void sk_path_rquad_to(sk_path_t*, float dx0, float dy0, float dx1, float dy1); 41 | SK_C_API void sk_path_rconic_to(sk_path_t*, float dx0, float dy0, float dx1, float dy1, float w); 42 | SK_C_API void sk_path_rcubic_to(sk_path_t*, float dx0, float dy0, float dx1, float dy1, float dx2, float dy2); 43 | SK_C_API void sk_path_add_rect_start(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir, uint32_t startIndex); 44 | SK_C_API void sk_path_add_arc(sk_path_t* cpath, const sk_rect_t* crect, float startAngle, float sweepAngle); 45 | SK_C_API sk_path_filltype_t sk_path_get_filltype(sk_path_t*); 46 | SK_C_API void sk_path_set_filltype(sk_path_t*, sk_path_filltype_t); 47 | SK_C_API void sk_path_transform(sk_path_t* cpath, const sk_matrix_t* cmatrix); 48 | SK_C_API sk_path_t* sk_path_clone(const sk_path_t* cpath); 49 | SK_C_API void sk_path_add_path_offset (sk_path_t* cpath, sk_path_t* other, float dx, float dy, sk_path_add_mode_t add_mode); 50 | SK_C_API void sk_path_add_path_matrix (sk_path_t* cpath, sk_path_t* other, sk_matrix_t *matrix, sk_path_add_mode_t add_mode); 51 | SK_C_API void sk_path_add_path (sk_path_t* cpath, sk_path_t* other, sk_path_add_mode_t add_mode); 52 | SK_C_API void sk_path_add_path_reverse (sk_path_t* cpath, sk_path_t* other); 53 | SK_C_API void sk_path_reset (sk_path_t* cpath); 54 | SK_C_API void sk_path_rewind (sk_path_t* cpath); 55 | SK_C_API int sk_path_count_points (const sk_path_t* cpath); 56 | SK_C_API int sk_path_count_verbs (const sk_path_t* cpath); 57 | SK_C_API void sk_path_get_point (const sk_path_t* cpath, int index, sk_point_t* point); 58 | SK_C_API int sk_path_get_points (const sk_path_t* cpath, sk_point_t* points, int max); 59 | SK_C_API bool sk_path_contains (const sk_path_t* cpath, float x, float y); 60 | SK_C_API sk_path_convexity_t sk_path_get_convexity (const sk_path_t* cpath); 61 | SK_C_API void sk_path_set_convexity (sk_path_t* cpath, sk_path_convexity_t convexity); 62 | SK_C_API bool sk_path_parse_svg_string (sk_path_t* cpath, const char* str); 63 | SK_C_API void sk_path_to_svg_string (const sk_path_t* cpath, sk_string_t* str); 64 | SK_C_API bool sk_path_get_last_point (const sk_path_t* cpath, sk_point_t* point); 65 | SK_C_API int sk_path_convert_conic_to_quads(const sk_point_t* p0, const sk_point_t* p1, const sk_point_t* p2, float w, sk_point_t* pts, int pow2); 66 | SK_C_API void sk_path_add_poly(sk_path_t* cpath, const sk_point_t* points, int count, bool close); 67 | SK_C_API uint32_t sk_path_get_segment_masks(sk_path_t* cpath); 68 | SK_C_API bool sk_path_is_oval(sk_path_t* cpath, sk_rect_t* bounds); 69 | SK_C_API bool sk_path_is_rrect(sk_path_t* cpath, sk_rrect_t* bounds); 70 | SK_C_API bool sk_path_is_line(sk_path_t* cpath, sk_point_t line [2]); 71 | SK_C_API bool sk_path_is_rect(sk_path_t* cpath, sk_rect_t* rect, bool* isClosed, sk_path_direction_t* direction); 72 | 73 | /* Iterators */ 74 | SK_C_API sk_path_iterator_t* sk_path_create_iter (sk_path_t *cpath, int forceClose); 75 | SK_C_API sk_path_verb_t sk_path_iter_next (sk_path_iterator_t *iterator, sk_point_t points [4], int doConsumeDegenerates, int exact); 76 | SK_C_API float sk_path_iter_conic_weight (sk_path_iterator_t *iterator); 77 | SK_C_API int sk_path_iter_is_close_line (sk_path_iterator_t *iterator); 78 | SK_C_API int sk_path_iter_is_closed_contour (sk_path_iterator_t *iterator); 79 | SK_C_API void sk_path_iter_destroy (sk_path_iterator_t *iterator); 80 | 81 | /* Raw iterators */ 82 | SK_C_API sk_path_rawiterator_t* sk_path_create_rawiter (sk_path_t *cpath); 83 | SK_C_API sk_path_verb_t sk_path_rawiter_peek (sk_path_rawiterator_t *iterator); 84 | SK_C_API sk_path_verb_t sk_path_rawiter_next (sk_path_rawiterator_t *iterator, sk_point_t points [4]); 85 | SK_C_API float sk_path_rawiter_conic_weight (sk_path_rawiterator_t *iterator); 86 | SK_C_API void sk_path_rawiter_destroy (sk_path_rawiterator_t *iterator); 87 | 88 | /* Path Ops */ 89 | SK_C_API bool sk_pathop_op(const sk_path_t* one, const sk_path_t* two, sk_pathop_t op, sk_path_t* result); 90 | SK_C_API bool sk_pathop_simplify(const sk_path_t* path, sk_path_t* result); 91 | SK_C_API bool sk_pathop_tight_bounds(const sk_path_t* path, sk_rect_t* result); 92 | 93 | /* Path Op Builder */ 94 | SK_C_API sk_opbuilder_t* sk_opbuilder_new(void); 95 | SK_C_API void sk_opbuilder_destroy(sk_opbuilder_t* builder); 96 | SK_C_API void sk_opbuilder_add(sk_opbuilder_t* builder, const sk_path_t* path, sk_pathop_t op); 97 | SK_C_API bool sk_opbuilder_resolve(sk_opbuilder_t* builder, sk_path_t* result); 98 | 99 | /* Path Measure */ 100 | SK_C_API sk_pathmeasure_t* sk_pathmeasure_new(void); 101 | SK_C_API sk_pathmeasure_t* sk_pathmeasure_new_with_path(const sk_path_t* path, bool forceClosed, float resScale); 102 | SK_C_API void sk_pathmeasure_destroy(sk_pathmeasure_t* pathMeasure); 103 | SK_C_API void sk_pathmeasure_set_path(sk_pathmeasure_t* pathMeasure, const sk_path_t* path, bool forceClosed); 104 | SK_C_API float sk_pathmeasure_get_length(sk_pathmeasure_t* pathMeasure); 105 | SK_C_API bool sk_pathmeasure_get_pos_tan(sk_pathmeasure_t* pathMeasure, float distance, sk_point_t* position, sk_vector_t* tangent); 106 | SK_C_API bool sk_pathmeasure_get_matrix(sk_pathmeasure_t* pathMeasure, float distance, sk_matrix_t* matrix, sk_pathmeasure_matrixflags_t flags); 107 | SK_C_API bool sk_pathmeasure_get_segment(sk_pathmeasure_t* pathMeasure, float start, float stop, sk_path_t* dst, bool startWithMoveTo); 108 | SK_C_API bool sk_pathmeasure_is_closed(sk_pathmeasure_t* pathMeasure); 109 | SK_C_API bool sk_pathmeasure_next_contour(sk_pathmeasure_t* pathMeasure); 110 | 111 | SK_C_PLUS_PLUS_END_GUARD 112 | 113 | #endif 114 | -------------------------------------------------------------------------------- /include/c/sk_types.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 Google Inc. 3 | * Copyright 2015 Xamarin Inc. 4 | * Copyright 2017 Microsoft Corporation. All rights reserved. 5 | * 6 | * Use of this source code is governed by a BSD-style license that can be 7 | * found in the LICENSE file. 8 | */ 9 | 10 | #ifndef sk_types_DEFINED 11 | #define sk_types_DEFINED 12 | 13 | #include 14 | #include 15 | 16 | #ifdef __cplusplus 17 | #define SK_C_PLUS_PLUS_BEGIN_GUARD extern "C" { 18 | #define SK_C_PLUS_PLUS_END_GUARD } 19 | #else 20 | #include 21 | #define SK_C_PLUS_PLUS_BEGIN_GUARD 22 | #define SK_C_PLUS_PLUS_END_GUARD 23 | #endif 24 | 25 | #if !defined(SK_C_API) 26 | #if defined(SKIA_C_DLL) 27 | #if defined(_MSC_VER) 28 | #if SKIA_IMPLEMENTATION 29 | #define SK_C_API __declspec(dllexport) 30 | #else 31 | #define SK_C_API __declspec(dllimport) 32 | #endif 33 | #else 34 | #define SK_C_API __attribute__((visibility("default"))) 35 | #endif 36 | #else 37 | #define SK_C_API 38 | #endif 39 | #endif 40 | 41 | /////////////////////////////////////////////////////////////////////////////////////// 42 | 43 | SK_C_PLUS_PLUS_BEGIN_GUARD 44 | 45 | typedef struct sk_refcnt_t sk_refcnt_t; 46 | typedef struct sk_nvrefcnt_t sk_nvrefcnt_t; 47 | 48 | typedef uint32_t sk_color_t; 49 | typedef uint32_t sk_pmcolor_t; 50 | 51 | /* This macro assumes all arguments are >=0 and <=255. */ 52 | #define sk_color_set_argb(a, r, g, b) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)) 53 | #define sk_color_get_a(c) (((c) >> 24) & 0xFF) 54 | #define sk_color_get_r(c) (((c) >> 16) & 0xFF) 55 | #define sk_color_get_g(c) (((c) >> 8) & 0xFF) 56 | #define sk_color_get_b(c) (((c) >> 0) & 0xFF) 57 | 58 | typedef enum { 59 | UNKNOWN_SK_COLORTYPE = 0, 60 | ALPHA_8_SK_COLORTYPE, 61 | RGB_565_SK_COLORTYPE, 62 | ARGB_4444_SK_COLORTYPE, 63 | RGBA_8888_SK_COLORTYPE, 64 | RGB_888X_SK_COLORTYPE, 65 | BGRA_8888_SK_COLORTYPE, 66 | RGBA_1010102_SK_COLORTYPE, 67 | RGB_101010X_SK_COLORTYPE, 68 | GRAY_8_SK_COLORTYPE, 69 | RGBA_F16_SK_COLORTYPE, 70 | } sk_colortype_t; 71 | 72 | typedef enum { 73 | UNKNOWN_SK_ALPHATYPE, 74 | OPAQUE_SK_ALPHATYPE, 75 | PREMUL_SK_ALPHATYPE, 76 | UNPREMUL_SK_ALPHATYPE, 77 | } sk_alphatype_t; 78 | 79 | typedef enum { 80 | UNKNOWN_SK_PIXELGEOMETRY, 81 | RGB_H_SK_PIXELGEOMETRY, 82 | BGR_H_SK_PIXELGEOMETRY, 83 | RGB_V_SK_PIXELGEOMETRY, 84 | BGR_V_SK_PIXELGEOMETRY, 85 | } sk_pixelgeometry_t; 86 | 87 | typedef enum { 88 | NONE_SK_SURFACE_PROPS_FLAGS = 0, 89 | USE_DEVICE_INDEPENDENT_FONTS_SK_SURFACE_PROPS_FLAGS = 1 << 0, 90 | } sk_surfaceprops_flags_t; 91 | 92 | typedef struct sk_surfaceprops_t sk_surfaceprops_t; 93 | 94 | typedef struct { 95 | float x; 96 | float y; 97 | } sk_point_t; 98 | 99 | typedef sk_point_t sk_vector_t; 100 | 101 | typedef struct { 102 | int32_t left; 103 | int32_t top; 104 | int32_t right; 105 | int32_t bottom; 106 | } sk_irect_t; 107 | 108 | typedef struct { 109 | float left; 110 | float top; 111 | float right; 112 | float bottom; 113 | } sk_rect_t; 114 | 115 | typedef struct { 116 | float scaleX, skewX, transX; 117 | float skewY, scaleY, transY; 118 | float persp0, persp1, persp2; 119 | } sk_matrix_t; 120 | 121 | typedef struct sk_matrix44_t sk_matrix44_t; 122 | 123 | typedef enum { 124 | IDENTITY_SK_MATRIX44_TYPE_MASK = 0, 125 | TRANSLATE_SK_MATRIX44_TYPE_MASK = 0x01, 126 | SCALE_SK_MATRIX44_TYPE_MASK = 0x02, 127 | AFFINE_SK_MATRIX44_TYPE_MASK = 0x04, 128 | PERSPECTIVE_SK_MATRIX44_TYPE_MASK = 0x08 129 | } sk_matrix44_type_mask_t; 130 | 131 | /** 132 | A sk_canvas_t encapsulates all of the state about drawing into a 133 | destination This includes a reference to the destination itself, 134 | and a stack of matrix/clip values. 135 | */ 136 | typedef struct sk_canvas_t sk_canvas_t; 137 | typedef struct sk_nodraw_canvas_t sk_nodraw_canvas_t; 138 | typedef struct sk_nway_canvas_t sk_nway_canvas_t; 139 | typedef struct sk_overdraw_canvas_t sk_overdraw_canvas_t; 140 | /** 141 | A sk_data_ holds an immutable data buffer. 142 | */ 143 | typedef struct sk_data_t sk_data_t; 144 | /** 145 | A sk_drawable_t is a abstraction for drawings that changed while 146 | drawing. 147 | */ 148 | typedef struct sk_drawable_t sk_drawable_t; 149 | /** 150 | A sk_image_t is an abstraction for drawing a rectagle of pixels. 151 | The content of the image is always immutable, though the actual 152 | storage may change, if for example that image can be re-created via 153 | encoded data or other means. 154 | */ 155 | typedef struct sk_image_t sk_image_t; 156 | /** 157 | A sk_maskfilter_t is an object that perform transformations on an 158 | alpha-channel mask before drawing it; it may be installed into a 159 | sk_paint_t. Each time a primitive is drawn, it is first 160 | scan-converted into a alpha mask, which os handed to the 161 | maskfilter, which may create a new mask is to render into the 162 | destination. 163 | */ 164 | typedef struct sk_maskfilter_t sk_maskfilter_t; 165 | /** 166 | A sk_paint_t holds the style and color information about how to 167 | draw geometries, text and bitmaps. 168 | */ 169 | typedef struct sk_paint_t sk_paint_t; 170 | /** 171 | A sk_path_t encapsulates compound (multiple contour) geometric 172 | paths consisting of straight line segments, quadratic curves, and 173 | cubic curves. 174 | */ 175 | typedef struct sk_path_t sk_path_t; 176 | /** 177 | A sk_picture_t holds recorded canvas drawing commands to be played 178 | back at a later time. 179 | */ 180 | typedef struct sk_picture_t sk_picture_t; 181 | /** 182 | A sk_picture_recorder_t holds a sk_canvas_t that records commands 183 | to create a sk_picture_t. 184 | */ 185 | typedef struct sk_picture_recorder_t sk_picture_recorder_t; 186 | /** 187 | A sk_shader_t specifies the source color(s) for what is being drawn. If a 188 | paint has no shader, then the paint's color is used. If the paint 189 | has a shader, then the shader's color(s) are use instead, but they 190 | are modulated by the paint's alpha. 191 | */ 192 | typedef struct sk_shader_t sk_shader_t; 193 | /** 194 | A sk_surface_t holds the destination for drawing to a canvas. For 195 | raster drawing, the destination is an array of pixels in memory. 196 | For GPU drawing, the destination is a texture or a framebuffer. 197 | */ 198 | typedef struct sk_surface_t sk_surface_t; 199 | /** 200 | The sk_region encapsulates the geometric region used to specify 201 | clipping areas for drawing. 202 | */ 203 | typedef struct sk_region_t sk_region_t; 204 | 205 | typedef enum { 206 | CLEAR_SK_BLENDMODE, 207 | SRC_SK_BLENDMODE, 208 | DST_SK_BLENDMODE, 209 | SRCOVER_SK_BLENDMODE, 210 | DSTOVER_SK_BLENDMODE, 211 | SRCIN_SK_BLENDMODE, 212 | DSTIN_SK_BLENDMODE, 213 | SRCOUT_SK_BLENDMODE, 214 | DSTOUT_SK_BLENDMODE, 215 | SRCATOP_SK_BLENDMODE, 216 | DSTATOP_SK_BLENDMODE, 217 | XOR_SK_BLENDMODE, 218 | PLUS_SK_BLENDMODE, 219 | MODULATE_SK_BLENDMODE, 220 | SCREEN_SK_BLENDMODE, 221 | OVERLAY_SK_BLENDMODE, 222 | DARKEN_SK_BLENDMODE, 223 | LIGHTEN_SK_BLENDMODE, 224 | COLORDODGE_SK_BLENDMODE, 225 | COLORBURN_SK_BLENDMODE, 226 | HARDLIGHT_SK_BLENDMODE, 227 | SOFTLIGHT_SK_BLENDMODE, 228 | DIFFERENCE_SK_BLENDMODE, 229 | EXCLUSION_SK_BLENDMODE, 230 | MULTIPLY_SK_BLENDMODE, 231 | HUE_SK_BLENDMODE, 232 | SATURATION_SK_BLENDMODE, 233 | COLOR_SK_BLENDMODE, 234 | LUMINOSITY_SK_BLENDMODE, 235 | } sk_blendmode_t; 236 | 237 | ////////////////////////////////////////////////////////////////////////////////////////// 238 | 239 | typedef struct { 240 | float x; 241 | float y; 242 | float z; 243 | } sk_point3_t; 244 | 245 | typedef struct { 246 | int32_t x; 247 | int32_t y; 248 | } sk_ipoint_t; 249 | 250 | typedef struct { 251 | float w; 252 | float h; 253 | } sk_size_t; 254 | 255 | typedef struct { 256 | int32_t w; 257 | int32_t h; 258 | } sk_isize_t; 259 | 260 | typedef struct { 261 | uint32_t fFlags; 262 | float fTop; 263 | float fAscent; 264 | float fDescent; 265 | float fBottom; 266 | float fLeading; 267 | float fAvgCharWidth; 268 | float fMaxCharWidth; 269 | float fXMin; 270 | float fXMax; 271 | float fXHeight; 272 | float fCapHeight; 273 | float fUnderlineThickness; 274 | float fUnderlinePosition; 275 | float fStrikeoutThickness; 276 | float fStrikeoutPosition; 277 | } sk_fontmetrics_t; 278 | 279 | // Flags for fFlags member of sk_fontmetrics_t 280 | #define FONTMETRICS_FLAGS_UNDERLINE_THICKNESS_IS_VALID (1U << 0) 281 | #define FONTMETRICS_FLAGS_UNDERLINE_POSITION_IS_VALID (1U << 1) 282 | 283 | /** 284 | A lightweight managed string. 285 | */ 286 | typedef struct sk_string_t sk_string_t; 287 | /** 288 | 289 | A sk_bitmap_t is an abstraction that specifies a raster bitmap. 290 | */ 291 | typedef struct sk_bitmap_t sk_bitmap_t; 292 | typedef struct sk_pixmap_t sk_pixmap_t; 293 | typedef struct sk_colorfilter_t sk_colorfilter_t; 294 | typedef struct sk_imagefilter_t sk_imagefilter_t; 295 | typedef struct sk_imagefilter_croprect_t sk_imagefilter_croprect_t; 296 | 297 | /** 298 | A sk_typeface_t pecifies the typeface and intrinsic style of a font. 299 | This is used in the paint, along with optionally algorithmic settings like 300 | textSize, textSkewX, textScaleX, kFakeBoldText_Mask, to specify 301 | how text appears when drawn (and measured). 302 | 303 | Typeface objects are immutable, and so they can be shared between threads. 304 | */ 305 | typedef struct sk_typeface_t sk_typeface_t; 306 | typedef uint32_t sk_font_table_tag_t; 307 | typedef struct sk_fontmgr_t sk_fontmgr_t; 308 | typedef struct sk_fontstyle_t sk_fontstyle_t; 309 | typedef struct sk_fontstyleset_t sk_fontstyleset_t; 310 | /** 311 | * Abstraction layer directly on top of an image codec. 312 | */ 313 | typedef struct sk_codec_t sk_codec_t; 314 | typedef struct sk_colorspace_t sk_colorspace_t; 315 | /** 316 | Various stream types 317 | */ 318 | typedef struct sk_stream_t sk_stream_t; 319 | typedef struct sk_stream_filestream_t sk_stream_filestream_t; 320 | typedef struct sk_stream_asset_t sk_stream_asset_t; 321 | typedef struct sk_stream_memorystream_t sk_stream_memorystream_t; 322 | typedef struct sk_stream_streamrewindable_t sk_stream_streamrewindable_t; 323 | typedef struct sk_wstream_t sk_wstream_t; 324 | typedef struct sk_wstream_filestream_t sk_wstream_filestream_t; 325 | typedef struct sk_wstream_dynamicmemorystream_t sk_wstream_dynamicmemorystream_t; 326 | /** 327 | High-level API for creating a document-based canvas. 328 | */ 329 | typedef struct sk_document_t sk_document_t; 330 | 331 | typedef enum { 332 | UTF8_SK_ENCODING, 333 | UTF16_SK_ENCODING, 334 | UTF32_SK_ENCODING 335 | } sk_encoding_t; 336 | 337 | typedef enum { 338 | POINTS_SK_POINT_MODE, 339 | LINES_SK_POINT_MODE, 340 | POLYGON_SK_POINT_MODE 341 | } sk_point_mode_t; 342 | 343 | typedef enum { 344 | LEFT_SK_TEXT_ALIGN, 345 | CENTER_SK_TEXT_ALIGN, 346 | RIGHT_SK_TEXT_ALIGN 347 | } sk_text_align_t; 348 | 349 | typedef enum { 350 | UTF8_SK_TEXT_ENCODING, 351 | UTF16_SK_TEXT_ENCODING, 352 | UTF32_SK_TEXT_ENCODING, 353 | GLYPH_ID_SK_TEXT_ENCODING 354 | } sk_text_encoding_t; 355 | 356 | typedef enum { 357 | WINDING_SK_PATH_FILLTYPE, 358 | EVENODD_SK_PATH_FILLTYPE, 359 | INVERSE_WINDING_SK_PATH_FILLTYPE, 360 | INVERSE_EVENODD_SK_PATH_FILLTYPE, 361 | } sk_path_filltype_t; 362 | 363 | typedef enum { 364 | UPRIGHT_SK_FONT_STYLE_SLANT = 0, 365 | ITALIC_SK_FONT_STYLE_SLANT = 1, 366 | OBLIQUE_SK_FONT_STYLE_SLANT = 2, 367 | } sk_font_style_slant_t; 368 | 369 | typedef enum { 370 | NONE_SK_FILTER_QUALITY, 371 | LOW_SK_FILTER_QUALITY, 372 | MEDIUM_SK_FILTER_QUALITY, 373 | HIGH_SK_FILTER_QUALITY 374 | } sk_filter_quality_t; 375 | 376 | typedef enum { 377 | HAS_NONE_SK_CROP_RECT_FLAG = 0x00, 378 | HAS_LEFT_SK_CROP_RECT_FLAG = 0x01, 379 | HAS_TOP_SK_CROP_RECT_FLAG = 0x02, 380 | HAS_WIDTH_SK_CROP_RECT_FLAG = 0x04, 381 | HAS_HEIGHT_SK_CROP_RECT_FLAG = 0x08, 382 | HAS_ALL_SK_CROP_RECT_FLAG = 0x0F, 383 | } sk_crop_rect_flags_t; 384 | 385 | typedef enum { 386 | DRAW_SHADOW_AND_FOREGROUND_SK_DROP_SHADOW_IMAGE_FILTER_SHADOW_MODE, 387 | DRAW_SHADOW_ONLY_SK_DROP_SHADOW_IMAGE_FILTER_SHADOW_MODE, 388 | } sk_drop_shadow_image_filter_shadow_mode_t; 389 | 390 | typedef enum { 391 | UNKNOWN_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE, 392 | R_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE, 393 | G_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE, 394 | B_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE, 395 | A_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE, 396 | } sk_displacement_map_effect_channel_selector_type_t; 397 | 398 | typedef enum { 399 | CLAMP_SK_MATRIX_CONVOLUTION_TILEMODE, 400 | REPEAT_SK_MATRIX_CONVOLUTION_TILEMODE, 401 | CLAMP_TO_BLACK_SK_MATRIX_CONVOLUTION_TILEMODE, 402 | } sk_matrix_convolution_tilemode_t; 403 | 404 | /** 405 | The logical operations that can be performed when combining two regions. 406 | */ 407 | typedef enum { 408 | DIFFERENCE_SK_REGION_OP, //!< subtract the op region from the first region 409 | INTERSECT_SK_REGION_OP, //!< intersect the two regions 410 | UNION_SK_REGION_OP, //!< union (inclusive-or) the two regions 411 | XOR_SK_REGION_OP, //!< exclusive-or the two regions 412 | REVERSE_DIFFERENCE_SK_REGION_OP, //!< subtract the first region from the op region 413 | REPLACE_SK_REGION_OP, //!< replace the dst region with the op region 414 | } sk_region_op_t; 415 | 416 | typedef enum { 417 | DIFFERENCE_SK_CLIPOP, 418 | INTERSECT_SK_CLIPOP, 419 | } sk_clipop_t; 420 | 421 | /** 422 | * Enum describing format of encoded data. 423 | */ 424 | typedef enum { 425 | BMP_SK_ENCODED_FORMAT, 426 | GIF_SK_ENCODED_FORMAT, 427 | ICO_SK_ENCODED_FORMAT, 428 | JPEG_SK_ENCODED_FORMAT, 429 | PNG_SK_ENCODED_FORMAT, 430 | WBMP_SK_ENCODED_FORMAT, 431 | WEBP_SK_ENCODED_FORMAT, 432 | PKM_SK_ENCODED_FORMAT, 433 | KTX_SK_ENCODED_FORMAT, 434 | ASTC_SK_ENCODED_FORMAT, 435 | DNG_SK_ENCODED_FORMAT, 436 | HEIF_SK_ENCODED_FORMAT, 437 | } sk_encoded_image_format_t; 438 | 439 | typedef enum { 440 | TOP_LEFT_SK_ENCODED_ORIGIN = 1, // Default 441 | TOP_RIGHT_SK_ENCODED_ORIGIN = 2, // Reflected across y-axis 442 | BOTTOM_RIGHT_SK_ENCODED_ORIGIN = 3, // Rotated 180 443 | BOTTOM_LEFT_SK_ENCODED_ORIGIN = 4, // Reflected across x-axis 444 | LEFT_TOP_SK_ENCODED_ORIGIN = 5, // Reflected across x-axis, Rotated 90 CCW 445 | RIGHT_TOP_SK_ENCODED_ORIGIN = 6, // Rotated 90 CW 446 | RIGHT_BOTTOM_SK_ENCODED_ORIGIN = 7, // Reflected across x-axis, Rotated 90 CW 447 | LEFT_BOTTOM_SK_ENCODED_ORIGIN = 8, // Rotated 90 CCW 448 | DEFAULT_SK_ENCODED_ORIGIN = TOP_LEFT_SK_ENCODED_ORIGIN, 449 | } sk_encodedorigin_t; 450 | 451 | typedef enum { 452 | SUCCESS_SK_CODEC_RESULT, 453 | INCOMPLETE_INPUT_SK_CODEC_RESULT, 454 | ERROR_IN_INPUT_SK_CODEC_RESULT, 455 | INVALID_CONVERSION_SK_CODEC_RESULT, 456 | INVALID_SCALE_SK_CODEC_RESULT, 457 | INVALID_PARAMETERS_SK_CODEC_RESULT, 458 | INVALID_INPUT_SK_CODEC_RESULT, 459 | COULD_NOT_REWIND_SK_CODEC_RESULT, 460 | INTERNAL_ERROR_SK_CODEC_RESULT, 461 | UNIMPLEMENTED_SK_CODEC_RESULT, 462 | } sk_codec_result_t; 463 | 464 | typedef enum { 465 | YES_SK_CODEC_ZERO_INITIALIZED, 466 | NO_SK_CODEC_ZERO_INITIALIZED, 467 | } sk_codec_zero_initialized_t; 468 | 469 | typedef enum { 470 | RESPECT_SK_TRANSFER_FUNCTION_BEHAVIOR, 471 | IGNORE_SK_TRANSFER_FUNCTION_BEHAVIOR, 472 | } sk_transfer_function_behavior_t; 473 | 474 | typedef struct { 475 | sk_codec_zero_initialized_t fZeroInitialized; 476 | sk_irect_t* fSubset; 477 | int fFrameIndex; 478 | int fPriorFrame; 479 | sk_transfer_function_behavior_t fPremulBehavior; 480 | } sk_codec_options_t; 481 | 482 | typedef enum { 483 | TOP_DOWN_SK_CODEC_SCANLINE_ORDER, 484 | BOTTOM_UP_SK_CODEC_SCANLINE_ORDER, 485 | } sk_codec_scanline_order_t; 486 | 487 | // The verbs that can be foudn on a path 488 | typedef enum { 489 | MOVE_SK_PATH_VERB, 490 | LINE_SK_PATH_VERB, 491 | QUAD_SK_PATH_VERB, 492 | CONIC_SK_PATH_VERB, 493 | CUBIC_SK_PATH_VERB, 494 | CLOSE_SK_PATH_VERB, 495 | DONE_SK_PATH_VERB 496 | } sk_path_verb_t; 497 | 498 | typedef struct sk_path_iterator_t sk_path_iterator_t; 499 | typedef struct sk_path_rawiterator_t sk_path_rawiterator_t; 500 | 501 | typedef enum { 502 | APPEND_SK_PATH_ADD_MODE, 503 | EXTEND_SK_PATH_ADD_MODE, 504 | } sk_path_add_mode_t; 505 | 506 | typedef enum { 507 | LINE_SK_PATH_SEGMENT_MASK = 1 << 0, 508 | QUAD_SK_PATH_SEGMENT_MASK = 1 << 1, 509 | CONIC_SK_PATH_SEGMENT_MASK = 1 << 2, 510 | CUBIC_SK_PATH_SEGMENT_MASK = 1 << 3, 511 | } sk_path_segment_mask_t; 512 | 513 | typedef enum { 514 | TRANSLATE_SK_PATH_EFFECT_1D_STYLE, 515 | ROTATE_SK_PATH_EFFECT_1D_STYLE, 516 | MORPH_SK_PATH_EFFECT_1D_STYLE, 517 | } sk_path_effect_1d_style_t; 518 | 519 | typedef enum { 520 | NORMAL_SK_PATH_EFFECT_TRIM_MODE, 521 | INVERTED_SK_PATH_EFFECT_TRIM_MODE, 522 | } sk_path_effect_trim_mode_t; 523 | 524 | typedef struct sk_path_effect_t sk_path_effect_t; 525 | 526 | typedef enum { 527 | BUTT_SK_STROKE_CAP, 528 | ROUND_SK_STROKE_CAP, 529 | SQUARE_SK_STROKE_CAP 530 | } sk_stroke_cap_t; 531 | 532 | typedef enum { 533 | MITER_SK_STROKE_JOIN, 534 | ROUND_SK_STROKE_JOIN, 535 | BEVEL_SK_STROKE_JOIN 536 | } sk_stroke_join_t; 537 | 538 | typedef enum { 539 | CLAMP_SK_SHADER_TILEMODE, 540 | REPEAT_SK_SHADER_TILEMODE, 541 | MIRROR_SK_SHADER_TILEMODE, 542 | } sk_shader_tilemode_t; 543 | 544 | typedef enum { 545 | NORMAL_SK_BLUR_STYLE, //!< fuzzy inside and outside 546 | SOLID_SK_BLUR_STYLE, //!< solid inside, fuzzy outside 547 | OUTER_SK_BLUR_STYLE, //!< nothing inside, fuzzy outside 548 | INNER_SK_BLUR_STYLE, //!< fuzzy inside, nothing outside 549 | } sk_blurstyle_t; 550 | 551 | typedef enum { 552 | CW_SK_PATH_DIRECTION, 553 | CCW_SK_PATH_DIRECTION, 554 | } sk_path_direction_t; 555 | 556 | typedef enum { 557 | SMALL_SK_PATH_ARC_SIZE, 558 | LARGE_SK_PATH_ARC_SIZE, 559 | } sk_path_arc_size_t; 560 | 561 | typedef enum { 562 | FILL_SK_PAINT_STYLE, 563 | STROKE_SK_PAINT_STYLE, 564 | STROKE_AND_FILL_SK_PAINT_STYLE, 565 | } sk_paint_style_t; 566 | 567 | typedef enum { 568 | NO_HINTING_SK_PAINT_HINTING, 569 | SLIGHT_HINTING_SK_PAINT_HINTING, 570 | NORMAL_HINTING_SK_PAINT_HINTING, 571 | FULL_HINTING_SK_PAINT_HINTING, 572 | } sk_paint_hinting_t; 573 | 574 | typedef struct sk_colortable_t sk_colortable_t; 575 | 576 | typedef struct sk_pixelref_factory_t sk_pixelref_factory_t; 577 | 578 | typedef enum { 579 | TOP_LEFT_GR_SURFACE_ORIGIN, 580 | BOTTOM_LEFT_GR_SURFACE_ORIGIN, 581 | } gr_surfaceorigin_t; 582 | 583 | typedef enum { 584 | UNKNOWN_GR_PIXEL_CONFIG, 585 | ALPHA_8_GR_PIXEL_CONFIG, 586 | GRAY_8_GR_PIXEL_CONFIG, 587 | RGB_565_GR_PIXEL_CONFIG, 588 | RGBA_4444_GR_PIXEL_CONFIG, 589 | RGBA_8888_GR_PIXEL_CONFIG, 590 | RGB_888_GR_PIXEL_CONFIG, 591 | BGRA_8888_GR_PIXEL_CONFIG, 592 | SRGBA_8888_GR_PIXEL_CONFIG, 593 | SBGRA_8888_GR_PIXEL_CONFIG, 594 | RGBA_1010102_GR_PIXEL_CONFIG, 595 | RGBA_FLOAT_GR_PIXEL_CONFIG, 596 | RG_FLOAT_GR_PIXEL_CONFIG, 597 | ALPHA_HALF_GR_PIXEL_CONFIG, 598 | RGBA_HALF_GR_PIXEL_CONFIG, 599 | } gr_pixelconfig_t; 600 | 601 | typedef enum { 602 | BW_SK_MASK_FORMAT, //!< 1bit per pixel mask (e.g. monochrome) 603 | A8_SK_MASK_FORMAT, //!< 8bits per pixel mask (e.g. antialiasing) 604 | THREE_D_SK_MASK_FORMAT, //!< 3 8bit per pixl planes: alpha, mul, add 605 | ARGB32_SK_MASK_FORMAT, //!< SkPMColor 606 | LCD16_SK_MASK_FORMAT, //!< 565 alpha for r/g/b 607 | } sk_mask_format_t; 608 | 609 | typedef struct { 610 | uint8_t* fImage; 611 | sk_irect_t fBounds; 612 | uint32_t fRowBytes; 613 | sk_mask_format_t fFormat; 614 | } sk_mask_t; 615 | 616 | typedef intptr_t gr_backendobject_t; 617 | 618 | typedef struct gr_backendrendertarget_t gr_backendrendertarget_t; 619 | typedef struct gr_backendtexture_t gr_backendtexture_t; 620 | 621 | typedef struct gr_context_t gr_context_t; 622 | 623 | typedef enum { 624 | METAL_GR_BACKEND, 625 | OPENGL_GR_BACKEND, 626 | VULKAN_GR_BACKEND, 627 | } gr_backend_t; 628 | 629 | typedef intptr_t gr_backendcontext_t; 630 | 631 | typedef struct gr_glinterface_t gr_glinterface_t; 632 | 633 | typedef void (*gr_gl_func_ptr)(void); 634 | typedef gr_gl_func_ptr (*gr_gl_get_proc)(void* ctx, const char* name); 635 | 636 | typedef struct { 637 | unsigned int fTarget; 638 | unsigned int fID; 639 | unsigned int fFormat; 640 | } gr_gl_textureinfo_t; 641 | 642 | typedef struct { 643 | unsigned int fFBOID; 644 | unsigned int fFormat; 645 | } gr_gl_framebufferinfo_t; 646 | 647 | typedef enum { 648 | DIFFERENCE_SK_PATHOP, 649 | INTERSECT_SK_PATHOP, 650 | UNION_SK_PATHOP, 651 | XOR_SK_PATHOP, 652 | REVERSE_DIFFERENCE_SK_PATHOP, 653 | } sk_pathop_t; 654 | 655 | typedef struct sk_opbuilder_t sk_opbuilder_t; 656 | 657 | typedef enum { 658 | UNKNOWN_SK_PATH_CONVEXITY, 659 | CONVEX_SK_PATH_CONVEXITY, 660 | CONCAVE_SK_PATH_CONVEXITY, 661 | } sk_path_convexity_t; 662 | 663 | typedef enum { 664 | DEFAULT_SK_LATTICE_RECT_TYPE, 665 | TRANSPARENT_SK_LATTICE_RECT_TYPE, 666 | FIXED_COLOR_SK_LATTICE_RECT_TYPE, 667 | } sk_lattice_recttype_t; 668 | 669 | typedef struct { 670 | const int* fXDivs; 671 | const int* fYDivs; 672 | const sk_lattice_recttype_t* fRectTypes; 673 | int fXCount; 674 | int fYCount; 675 | const sk_irect_t* fBounds; 676 | const sk_color_t* fColors; 677 | } sk_lattice_t; 678 | 679 | typedef struct sk_pathmeasure_t sk_pathmeasure_t; 680 | 681 | typedef enum { 682 | GET_POSITION_SK_PATHMEASURE_MATRIXFLAGS = 0x01, 683 | GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS = 0x02, 684 | GET_POS_AND_TAN_SK_PATHMEASURE_MATRIXFLAGS = GET_POSITION_SK_PATHMEASURE_MATRIXFLAGS | GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS, 685 | } sk_pathmeasure_matrixflags_t; 686 | 687 | typedef void (*sk_bitmap_release_proc)(void* addr, void* context); 688 | 689 | typedef void (*sk_data_release_proc)(const void* ptr, void* context); 690 | 691 | typedef void (*sk_image_raster_release_proc)(const void* addr, void* context); 692 | typedef void (*sk_image_texture_release_proc)(void* context); 693 | 694 | typedef void (*sk_surface_raster_release_proc)(void* addr, void* context); 695 | 696 | typedef enum { 697 | ALLOW_SK_IMAGE_CACHING_HINT, 698 | DISALLOW_SK_IMAGE_CACHING_HINT, 699 | } sk_image_caching_hint_t; 700 | 701 | typedef enum { 702 | NONE_SK_BITMAP_ALLOC_FLAGS = 0, 703 | ZERO_PIXELS_SK_BITMAP_ALLOC_FLAGS = 1 << 0, 704 | } sk_bitmap_allocflags_t; 705 | 706 | typedef struct { 707 | int16_t fTimeZoneMinutes; 708 | uint16_t fYear; 709 | uint8_t fMonth; 710 | uint8_t fDayOfWeek; 711 | uint8_t fDay; 712 | uint8_t fHour; 713 | uint8_t fMinute; 714 | uint8_t fSecond; 715 | } sk_time_datetime_t; 716 | 717 | typedef struct { 718 | sk_string_t* fTitle; 719 | sk_string_t* fAuthor; 720 | sk_string_t* fSubject; 721 | sk_string_t* fKeywords; 722 | sk_string_t* fCreator; 723 | sk_string_t* fProducer; 724 | sk_time_datetime_t* fCreation; 725 | sk_time_datetime_t* fModified; 726 | float fRasterDPI; 727 | bool fPDFA; 728 | int fEncodingQuality; 729 | } sk_document_pdf_metadata_t; 730 | 731 | typedef struct { 732 | sk_colorspace_t* colorspace; 733 | int32_t width; 734 | int32_t height; 735 | sk_colortype_t colorType; 736 | sk_alphatype_t alphaType; 737 | } sk_imageinfo_t; 738 | 739 | typedef enum { 740 | KEEP_SK_CODEC_ANIMATION_DISPOSAL_METHOD = 1, 741 | RESTORE_BG_COLOR_SK_CODEC_ANIMATION_DISPOSAL_METHOD = 2, 742 | RESTORE_PREVIOUS_SK_CODEC_ANIMATION_DISPOSAL_METHOD = 3, 743 | } sk_codecanimation_disposalmethod_t; 744 | 745 | typedef struct { 746 | int fRequiredFrame; 747 | int fDuration; 748 | bool fFullyReceived; 749 | sk_alphatype_t fAlphaType; 750 | sk_codecanimation_disposalmethod_t fDisposalMethod; 751 | } sk_codec_frameinfo_t; 752 | 753 | typedef struct sk_xmlstreamwriter_t sk_xmlstreamwriter_t; 754 | typedef struct sk_xmlwriter_t sk_xmlwriter_t; 755 | 756 | typedef struct sk_svgcanvas_t sk_svgcanvas_t; 757 | 758 | typedef struct sk_3dview_t sk_3dview_t; 759 | 760 | typedef enum { 761 | TRIANGLES_SK_VERTICES_VERTEX_MODE, 762 | TRIANGLE_STRIP_SK_VERTICES_VERTEX_MODE, 763 | TRIANGLE_FAN_SK_VERTICES_VERTEX_MODE, 764 | } sk_vertices_vertex_mode_t; 765 | 766 | typedef struct sk_vertices_t sk_vertices_t; 767 | 768 | typedef enum { 769 | LINEAR_SK_GAMMA_NAMED, 770 | SRGB_SK_GAMMA_NAMED, 771 | TWO_DOT_TWO_CURVE_SK_GAMMA_NAMED, 772 | NON_STANDARD_SK_GAMMA_NAMED, 773 | } sk_gamma_named_t; 774 | 775 | typedef enum { 776 | RGB_SK_COLORSPACE_TYPE, 777 | CMYK_SK_COLORSPACE_TYPE, 778 | GRAY_SK_COLORSPACE_TYPE, 779 | } sk_colorspace_type_t; 780 | 781 | typedef enum { 782 | LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA, 783 | SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA, 784 | } sk_colorspace_render_target_gamma_t; 785 | 786 | typedef enum { 787 | SRGB_SK_COLORSPACE_GAMUT, 788 | ADOBE_RGB_SK_COLORSPACE_GAMUT, 789 | DCIP3_D65_SK_COLORSPACE_GAMUT, 790 | REC2020_SK_COLORSPACE_GAMUT, 791 | } sk_colorspace_gamut_t; 792 | 793 | typedef struct { 794 | float fG; 795 | float fA; 796 | float fB; 797 | float fC; 798 | float fD; 799 | float fE; 800 | float fF; 801 | } sk_colorspace_transfer_fn_t; 802 | 803 | typedef struct { 804 | float fRX; 805 | float fRY; 806 | float fGX; 807 | float fGY; 808 | float fBX; 809 | float fBY; 810 | float fWX; 811 | float fWY; 812 | } sk_colorspaceprimaries_t; 813 | 814 | typedef enum { 815 | NO_INVERT_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, 816 | INVERT_BRIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, 817 | INVERT_LIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, 818 | } sk_highcontrastconfig_invertstyle_t; 819 | 820 | typedef struct { 821 | bool fGrayscale; 822 | sk_highcontrastconfig_invertstyle_t fInvertStyle; 823 | float fContrast; 824 | } sk_highcontrastconfig_t; 825 | 826 | typedef enum { 827 | ZERO_SK_PNGENCODER_FILTER_FLAGS = 0x00, 828 | NONE_SK_PNGENCODER_FILTER_FLAGS = 0x08, 829 | SUB_SK_PNGENCODER_FILTER_FLAGS = 0x10, 830 | UP_SK_PNGENCODER_FILTER_FLAGS = 0x20, 831 | AVG_SK_PNGENCODER_FILTER_FLAGS = 0x40, 832 | PAETH_SK_PNGENCODER_FILTER_FLAGS = 0x80, 833 | ALL_SK_PNGENCODER_FILTER_FLAGS = NONE_SK_PNGENCODER_FILTER_FLAGS | 834 | SUB_SK_PNGENCODER_FILTER_FLAGS | 835 | UP_SK_PNGENCODER_FILTER_FLAGS | 836 | AVG_SK_PNGENCODER_FILTER_FLAGS | 837 | PAETH_SK_PNGENCODER_FILTER_FLAGS, 838 | } sk_pngencoder_filterflags_t; 839 | 840 | typedef struct { 841 | sk_pngencoder_filterflags_t fFilterFlags; 842 | int fZLibLevel; 843 | sk_transfer_function_behavior_t fUnpremulBehavior; 844 | void* fComments; 845 | } sk_pngencoder_options_t; 846 | 847 | typedef enum { 848 | DOWNSAMPLE_420_SK_JPEGENCODER_DOWNSAMPLE, 849 | DOWNSAMPLE_422_SK_JPEGENCODER_DOWNSAMPLE, 850 | DOWNSAMPLE_444_SK_JPEGENCODER_DOWNSAMPLE, 851 | } sk_jpegencoder_downsample_t; 852 | 853 | typedef enum { 854 | IGNORE_SK_JPEGENCODER_ALPHA_OPTION, 855 | BLEND_ON_BLACK_SK_JPEGENCODER_ALPHA_OPTION, 856 | } sk_jpegencoder_alphaoption_t; 857 | 858 | typedef struct { 859 | int fQuality; 860 | sk_jpegencoder_downsample_t fDownsample; 861 | sk_jpegencoder_alphaoption_t fAlphaOption; 862 | sk_transfer_function_behavior_t fBlendBehavior; 863 | } sk_jpegencoder_options_t; 864 | 865 | typedef enum { 866 | LOSSY_SK_WEBPENCODER_COMPTRESSION, 867 | LOSSLESS_SK_WEBPENCODER_COMPTRESSION, 868 | } sk_webpencoder_compression_t; 869 | 870 | typedef struct { 871 | sk_webpencoder_compression_t fCompression; 872 | float fQuality; 873 | sk_transfer_function_behavior_t fUnpremulBehavior; 874 | } sk_webpencoder_options_t; 875 | typedef struct sk_rrect_t sk_rrect_t; 876 | 877 | typedef enum { 878 | EMPTY_SK_RRECT_TYPE, 879 | RECT_SK_RRECT_TYPE, 880 | OVAL_SK_RRECT_TYPE, 881 | SIMPLE_SK_RRECT_TYPE, 882 | NINE_PATCH_SK_RRECT_TYPE, 883 | COMPLEX_SK_RRECT_TYPE, 884 | } sk_rrect_type_t; 885 | 886 | typedef enum { 887 | UPPER_LEFT_SK_RRECT_CORNER, 888 | UPPER_RIGHT_SK_RRECT_CORNER, 889 | LOWER_RIGHT_SK_RRECT_CORNER, 890 | LOWER_LEFT_SK_RRECT_CORNER, 891 | } sk_rrect_corner_t; 892 | 893 | typedef struct sk_textblob_t sk_textblob_t; 894 | typedef struct sk_textblob_builder_t sk_textblob_builder_t; 895 | 896 | typedef struct { 897 | void* glyphs; 898 | void* pos; 899 | void* utf8text; 900 | void* clusters; 901 | } sk_textblob_builder_runbuffer_t; 902 | 903 | typedef struct { 904 | float fSCos; 905 | float fSSin; 906 | float fTX; 907 | float fTY; 908 | } sk_rsxform_t; 909 | 910 | SK_C_PLUS_PLUS_END_GUARD 911 | 912 | #endif 913 | -------------------------------------------------------------------------------- /generated/index.c: -------------------------------------------------------------------------------- 1 | #define NAPI_EXPERIMENTAL 2 | 3 | #include 4 | #include 5 | 6 | #include "calls.c" 7 | 8 | #define DECLARE_NAPI_METHOD(name, func) \ 9 | { name, 0, func, 0, 0, 0, napi_default, 0 } 10 | 11 | napi_value Init(napi_env env, napi_value exports) { 12 | napi_status status; 13 | napi_property_descriptor desc[] = { DECLARE_NAPI_METHOD("getMemory", getMemory), DECLARE_NAPI_METHOD("grContextMakeGl", grContextMakeGl), DECLARE_NAPI_METHOD("grContextUnref", grContextUnref), DECLARE_NAPI_METHOD("grContextAbandonContext", grContextAbandonContext), DECLARE_NAPI_METHOD("grContextReleaseResourcesAndAbandonContext", grContextReleaseResourcesAndAbandonContext), DECLARE_NAPI_METHOD("grContextGetResourceCacheLimits", grContextGetResourceCacheLimits), DECLARE_NAPI_METHOD("grContextSetResourceCacheLimits", grContextSetResourceCacheLimits), DECLARE_NAPI_METHOD("grContextGetResourceCacheUsage", grContextGetResourceCacheUsage), DECLARE_NAPI_METHOD("grContextGetMaxSurfaceSampleCountForColorType", grContextGetMaxSurfaceSampleCountForColorType), DECLARE_NAPI_METHOD("grContextFlush", grContextFlush), DECLARE_NAPI_METHOD("grContextResetContext", grContextResetContext), DECLARE_NAPI_METHOD("grContextGetBackend", grContextGetBackend), DECLARE_NAPI_METHOD("grGlinterfaceCreateNativeInterface", grGlinterfaceCreateNativeInterface), DECLARE_NAPI_METHOD("grGlinterfaceAssembleInterface", grGlinterfaceAssembleInterface), DECLARE_NAPI_METHOD("grGlinterfaceAssembleGlInterface", grGlinterfaceAssembleGlInterface), DECLARE_NAPI_METHOD("grGlinterfaceAssembleGlesInterface", grGlinterfaceAssembleGlesInterface), DECLARE_NAPI_METHOD("grGlinterfaceUnref", grGlinterfaceUnref), DECLARE_NAPI_METHOD("grGlinterfaceValidate", grGlinterfaceValidate), DECLARE_NAPI_METHOD("grGlinterfaceHasExtension", grGlinterfaceHasExtension), DECLARE_NAPI_METHOD("grBackendtextureNewGl", grBackendtextureNewGl), DECLARE_NAPI_METHOD("grBackendtextureDelete", grBackendtextureDelete), DECLARE_NAPI_METHOD("grBackendtextureIsValid", grBackendtextureIsValid), DECLARE_NAPI_METHOD("grBackendtextureGetWidth", grBackendtextureGetWidth), DECLARE_NAPI_METHOD("grBackendtextureGetHeight", grBackendtextureGetHeight), DECLARE_NAPI_METHOD("grBackendtextureHasMipmaps", grBackendtextureHasMipmaps), DECLARE_NAPI_METHOD("grBackendtextureGetBackend", grBackendtextureGetBackend), DECLARE_NAPI_METHOD("grBackendtextureGetGlTextureinfo", grBackendtextureGetGlTextureinfo), DECLARE_NAPI_METHOD("grBackendrendertargetNewGl", grBackendrendertargetNewGl), DECLARE_NAPI_METHOD("grBackendrendertargetDelete", grBackendrendertargetDelete), DECLARE_NAPI_METHOD("grBackendrendertargetIsValid", grBackendrendertargetIsValid), DECLARE_NAPI_METHOD("grBackendrendertargetGetWidth", grBackendrendertargetGetWidth), DECLARE_NAPI_METHOD("grBackendrendertargetGetHeight", grBackendrendertargetGetHeight), DECLARE_NAPI_METHOD("grBackendrendertargetGetSamples", grBackendrendertargetGetSamples), DECLARE_NAPI_METHOD("grBackendrendertargetGetStencils", grBackendrendertargetGetStencils), DECLARE_NAPI_METHOD("grBackendrendertargetGetBackend", grBackendrendertargetGetBackend), DECLARE_NAPI_METHOD("grBackendrendertargetGetGlFramebufferinfo", grBackendrendertargetGetGlFramebufferinfo), DECLARE_NAPI_METHOD("skBitmapDestructor", skBitmapDestructor), DECLARE_NAPI_METHOD("skBitmapNew", skBitmapNew), DECLARE_NAPI_METHOD("skBitmapGetInfo", skBitmapGetInfo), DECLARE_NAPI_METHOD("skBitmapGetPixels", skBitmapGetPixels), DECLARE_NAPI_METHOD("skBitmapGetRowBytes", skBitmapGetRowBytes), DECLARE_NAPI_METHOD("skBitmapGetByteCount", skBitmapGetByteCount), DECLARE_NAPI_METHOD("skBitmapReset", skBitmapReset), DECLARE_NAPI_METHOD("skBitmapIsNull", skBitmapIsNull), DECLARE_NAPI_METHOD("skBitmapIsImmutable", skBitmapIsImmutable), DECLARE_NAPI_METHOD("skBitmapSetImmutable", skBitmapSetImmutable), DECLARE_NAPI_METHOD("skBitmapIsVolatile", skBitmapIsVolatile), DECLARE_NAPI_METHOD("skBitmapSetVolatile", skBitmapSetVolatile), DECLARE_NAPI_METHOD("skBitmapErase", skBitmapErase), DECLARE_NAPI_METHOD("skBitmapEraseRect", skBitmapEraseRect), DECLARE_NAPI_METHOD("skBitmapGetAddr_8", skBitmapGetAddr_8), DECLARE_NAPI_METHOD("skBitmapGetAddr_16", skBitmapGetAddr_16), DECLARE_NAPI_METHOD("skBitmapGetAddr_32", skBitmapGetAddr_32), DECLARE_NAPI_METHOD("skBitmapGetAddr", skBitmapGetAddr), DECLARE_NAPI_METHOD("skBitmapGetPixelColor", skBitmapGetPixelColor), DECLARE_NAPI_METHOD("skBitmapSetPixelColor", skBitmapSetPixelColor), DECLARE_NAPI_METHOD("skBitmapReadyToDraw", skBitmapReadyToDraw), DECLARE_NAPI_METHOD("skBitmapGetPixelColors", skBitmapGetPixelColors), DECLARE_NAPI_METHOD("skBitmapSetPixelColors", skBitmapSetPixelColors), DECLARE_NAPI_METHOD("skBitmapInstallPixels", skBitmapInstallPixels), DECLARE_NAPI_METHOD("skBitmapInstallPixelsWithPixmap", skBitmapInstallPixelsWithPixmap), DECLARE_NAPI_METHOD("skBitmapInstallMaskPixels", skBitmapInstallMaskPixels), DECLARE_NAPI_METHOD("skBitmapTryAllocPixels", skBitmapTryAllocPixels), DECLARE_NAPI_METHOD("skBitmapTryAllocPixelsWithFlags", skBitmapTryAllocPixelsWithFlags), DECLARE_NAPI_METHOD("skBitmapSetPixels", skBitmapSetPixels), DECLARE_NAPI_METHOD("skBitmapPeekPixels", skBitmapPeekPixels), DECLARE_NAPI_METHOD("skBitmapExtractSubset", skBitmapExtractSubset), DECLARE_NAPI_METHOD("skBitmapExtractAlpha", skBitmapExtractAlpha), DECLARE_NAPI_METHOD("skBitmapNotifyPixelsChanged", skBitmapNotifyPixelsChanged), DECLARE_NAPI_METHOD("skBitmapSwap", skBitmapSwap), DECLARE_NAPI_METHOD("skCanvasDestroy", skCanvasDestroy), DECLARE_NAPI_METHOD("skCanvasSave", skCanvasSave), DECLARE_NAPI_METHOD("skCanvasSaveLayer", skCanvasSaveLayer), DECLARE_NAPI_METHOD("skCanvasRestore", skCanvasRestore), DECLARE_NAPI_METHOD("skCanvasTranslate", skCanvasTranslate), DECLARE_NAPI_METHOD("skCanvasScale", skCanvasScale), DECLARE_NAPI_METHOD("skCanvasRotateDegrees", skCanvasRotateDegrees), DECLARE_NAPI_METHOD("skCanvasRotateRadians", skCanvasRotateRadians), DECLARE_NAPI_METHOD("skCanvasSkew", skCanvasSkew), DECLARE_NAPI_METHOD("skCanvasConcat", skCanvasConcat), DECLARE_NAPI_METHOD("skCanvasQuickReject", skCanvasQuickReject), DECLARE_NAPI_METHOD("skCanvasClipRegion", skCanvasClipRegion), DECLARE_NAPI_METHOD("skCanvasDrawPaint", skCanvasDrawPaint), DECLARE_NAPI_METHOD("skCanvasDrawRect", skCanvasDrawRect), DECLARE_NAPI_METHOD("skCanvasDrawRrect", skCanvasDrawRrect), DECLARE_NAPI_METHOD("skCanvasDrawRegion", skCanvasDrawRegion), DECLARE_NAPI_METHOD("skCanvasDrawCircle", skCanvasDrawCircle), DECLARE_NAPI_METHOD("skCanvasDrawOval", skCanvasDrawOval), DECLARE_NAPI_METHOD("skCanvasDrawPath", skCanvasDrawPath), DECLARE_NAPI_METHOD("skCanvasDrawImage", skCanvasDrawImage), DECLARE_NAPI_METHOD("skCanvasDrawImageRect", skCanvasDrawImageRect), DECLARE_NAPI_METHOD("skCanvasDrawPicture", skCanvasDrawPicture), DECLARE_NAPI_METHOD("skCanvasDrawDrawable", skCanvasDrawDrawable), DECLARE_NAPI_METHOD("skCanvasClear", skCanvasClear), DECLARE_NAPI_METHOD("skCanvasDiscard", skCanvasDiscard), DECLARE_NAPI_METHOD("skCanvasGetSaveCount", skCanvasGetSaveCount), DECLARE_NAPI_METHOD("skCanvasRestoreToCount", skCanvasRestoreToCount), DECLARE_NAPI_METHOD("skCanvasDrawColor", skCanvasDrawColor), DECLARE_NAPI_METHOD("skCanvasDrawPoints", skCanvasDrawPoints), DECLARE_NAPI_METHOD("skCanvasDrawPoint", skCanvasDrawPoint), DECLARE_NAPI_METHOD("skCanvasDrawLine", skCanvasDrawLine), DECLARE_NAPI_METHOD("skCanvasDrawText", skCanvasDrawText), DECLARE_NAPI_METHOD("skCanvasDrawPosText", skCanvasDrawPosText), DECLARE_NAPI_METHOD("skCanvasDrawTextOnPath", skCanvasDrawTextOnPath), DECLARE_NAPI_METHOD("skCanvasDrawTextBlob", skCanvasDrawTextBlob), DECLARE_NAPI_METHOD("skCanvasDrawBitmap", skCanvasDrawBitmap), DECLARE_NAPI_METHOD("skCanvasDrawBitmapRect", skCanvasDrawBitmapRect), DECLARE_NAPI_METHOD("skCanvasResetMatrix", skCanvasResetMatrix), DECLARE_NAPI_METHOD("skCanvasSetMatrix", skCanvasSetMatrix), DECLARE_NAPI_METHOD("skCanvasGetTotalMatrix", skCanvasGetTotalMatrix), DECLARE_NAPI_METHOD("skCanvasDrawRoundRect", skCanvasDrawRoundRect), DECLARE_NAPI_METHOD("skCanvasClipRectWithOperation", skCanvasClipRectWithOperation), DECLARE_NAPI_METHOD("skCanvasClipPathWithOperation", skCanvasClipPathWithOperation), DECLARE_NAPI_METHOD("skCanvasClipRrectWithOperation", skCanvasClipRrectWithOperation), DECLARE_NAPI_METHOD("skCanvasGetLocalClipBounds", skCanvasGetLocalClipBounds), DECLARE_NAPI_METHOD("skCanvasGetDeviceClipBounds", skCanvasGetDeviceClipBounds), DECLARE_NAPI_METHOD("skCanvasFlush", skCanvasFlush), DECLARE_NAPI_METHOD("skCanvasNewFromBitmap", skCanvasNewFromBitmap), DECLARE_NAPI_METHOD("skCanvasDrawAnnotation", skCanvasDrawAnnotation), DECLARE_NAPI_METHOD("skCanvasDrawUrlAnnotation", skCanvasDrawUrlAnnotation), DECLARE_NAPI_METHOD("skCanvasDrawNamedDestinationAnnotation", skCanvasDrawNamedDestinationAnnotation), DECLARE_NAPI_METHOD("skCanvasDrawLinkDestinationAnnotation", skCanvasDrawLinkDestinationAnnotation), DECLARE_NAPI_METHOD("skCanvasDrawBitmapLattice", skCanvasDrawBitmapLattice), DECLARE_NAPI_METHOD("skCanvasDrawImageLattice", skCanvasDrawImageLattice), DECLARE_NAPI_METHOD("skCanvasDrawBitmapNine", skCanvasDrawBitmapNine), DECLARE_NAPI_METHOD("skCanvasDrawImageNine", skCanvasDrawImageNine), DECLARE_NAPI_METHOD("skCanvasDrawVertices", skCanvasDrawVertices), DECLARE_NAPI_METHOD("skCanvasDrawArc", skCanvasDrawArc), DECLARE_NAPI_METHOD("skCanvasDrawDrrect", skCanvasDrawDrrect), DECLARE_NAPI_METHOD("skCanvasDrawAtlas", skCanvasDrawAtlas), DECLARE_NAPI_METHOD("skCanvasDrawPatch", skCanvasDrawPatch), DECLARE_NAPI_METHOD("skCanvasIsClipEmpty", skCanvasIsClipEmpty), DECLARE_NAPI_METHOD("skCanvasIsClipRect", skCanvasIsClipRect), DECLARE_NAPI_METHOD("skNodrawCanvasNew", skNodrawCanvasNew), DECLARE_NAPI_METHOD("skNodrawCanvasDestroy", skNodrawCanvasDestroy), DECLARE_NAPI_METHOD("skNwayCanvasNew", skNwayCanvasNew), DECLARE_NAPI_METHOD("skNwayCanvasDestroy", skNwayCanvasDestroy), DECLARE_NAPI_METHOD("skNwayCanvasAddCanvas", skNwayCanvasAddCanvas), DECLARE_NAPI_METHOD("skNwayCanvasRemoveCanvas", skNwayCanvasRemoveCanvas), DECLARE_NAPI_METHOD("skNwayCanvasRemoveAll", skNwayCanvasRemoveAll), DECLARE_NAPI_METHOD("skOverdrawCanvasNew", skOverdrawCanvasNew), DECLARE_NAPI_METHOD("skOverdrawCanvasDestroy", skOverdrawCanvasDestroy), DECLARE_NAPI_METHOD("skCodecMinBufferedBytesNeeded", skCodecMinBufferedBytesNeeded), DECLARE_NAPI_METHOD("skCodecNewFromStream", skCodecNewFromStream), DECLARE_NAPI_METHOD("skCodecNewFromData", skCodecNewFromData), DECLARE_NAPI_METHOD("skCodecDestroy", skCodecDestroy), DECLARE_NAPI_METHOD("skCodecGetInfo", skCodecGetInfo), DECLARE_NAPI_METHOD("skCodecGetOrigin", skCodecGetOrigin), DECLARE_NAPI_METHOD("skCodecGetScaledDimensions", skCodecGetScaledDimensions), DECLARE_NAPI_METHOD("skCodecGetValidSubset", skCodecGetValidSubset), DECLARE_NAPI_METHOD("skCodecGetEncodedFormat", skCodecGetEncodedFormat), DECLARE_NAPI_METHOD("skCodecGetPixels", skCodecGetPixels), DECLARE_NAPI_METHOD("skCodecStartIncrementalDecode", skCodecStartIncrementalDecode), DECLARE_NAPI_METHOD("skCodecIncrementalDecode", skCodecIncrementalDecode), DECLARE_NAPI_METHOD("skCodecStartScanlineDecode", skCodecStartScanlineDecode), DECLARE_NAPI_METHOD("skCodecGetScanlines", skCodecGetScanlines), DECLARE_NAPI_METHOD("skCodecSkipScanlines", skCodecSkipScanlines), DECLARE_NAPI_METHOD("skCodecGetScanlineOrder", skCodecGetScanlineOrder), DECLARE_NAPI_METHOD("skCodecNextScanline", skCodecNextScanline), DECLARE_NAPI_METHOD("skCodecOutputScanline", skCodecOutputScanline), DECLARE_NAPI_METHOD("skCodecGetFrameCount", skCodecGetFrameCount), DECLARE_NAPI_METHOD("skCodecGetFrameInfo", skCodecGetFrameInfo), DECLARE_NAPI_METHOD("skCodecGetFrameInfoForIndex", skCodecGetFrameInfoForIndex), DECLARE_NAPI_METHOD("skCodecGetRepetitionCount", skCodecGetRepetitionCount), DECLARE_NAPI_METHOD("skColorfilterUnref", skColorfilterUnref), DECLARE_NAPI_METHOD("skColorfilterNewMode", skColorfilterNewMode), DECLARE_NAPI_METHOD("skColorfilterNewLighting", skColorfilterNewLighting), DECLARE_NAPI_METHOD("skColorfilterNewCompose", skColorfilterNewCompose), DECLARE_NAPI_METHOD("skColorfilterNewColorMatrix", skColorfilterNewColorMatrix), DECLARE_NAPI_METHOD("skColorfilterNewLumaColor", skColorfilterNewLumaColor), DECLARE_NAPI_METHOD("skColorfilterNewHighContrast", skColorfilterNewHighContrast), DECLARE_NAPI_METHOD("skColorfilterNewTable", skColorfilterNewTable), DECLARE_NAPI_METHOD("skColorfilterNewTableArgb", skColorfilterNewTableArgb), DECLARE_NAPI_METHOD("skColorspaceUnref", skColorspaceUnref), DECLARE_NAPI_METHOD("skColorspaceNewSrgb", skColorspaceNewSrgb), DECLARE_NAPI_METHOD("skColorspaceNewSrgbLinear", skColorspaceNewSrgbLinear), DECLARE_NAPI_METHOD("skColorspaceNewIcc", skColorspaceNewIcc), DECLARE_NAPI_METHOD("skColorspaceNewRgbWithGamma", skColorspaceNewRgbWithGamma), DECLARE_NAPI_METHOD("skColorspaceNewRgbWithGammaAndGamut", skColorspaceNewRgbWithGammaAndGamut), DECLARE_NAPI_METHOD("skColorspaceNewRgbWithCoeffs", skColorspaceNewRgbWithCoeffs), DECLARE_NAPI_METHOD("skColorspaceNewRgbWithCoeffsAndGamut", skColorspaceNewRgbWithCoeffsAndGamut), DECLARE_NAPI_METHOD("skColorspaceNewRgbWithGammaNamed", skColorspaceNewRgbWithGammaNamed), DECLARE_NAPI_METHOD("skColorspaceNewRgbWithGammaNamedAndGamut", skColorspaceNewRgbWithGammaNamedAndGamut), DECLARE_NAPI_METHOD("skColorspaceGammaGetType", skColorspaceGammaGetType), DECLARE_NAPI_METHOD("skColorspaceGammaGetGammaNamed", skColorspaceGammaGetGammaNamed), DECLARE_NAPI_METHOD("skColorspaceGammaCloseToSrgb", skColorspaceGammaCloseToSrgb), DECLARE_NAPI_METHOD("skColorspaceGammaIsLinear", skColorspaceGammaIsLinear), DECLARE_NAPI_METHOD("skColorspaceIsSrgb", skColorspaceIsSrgb), DECLARE_NAPI_METHOD("skColorspaceEquals", skColorspaceEquals), DECLARE_NAPI_METHOD("skColorspaceToXyzd50", skColorspaceToXyzd50), DECLARE_NAPI_METHOD("skColorspaceAsToXyzd50", skColorspaceAsToXyzd50), DECLARE_NAPI_METHOD("skColorspaceAsFromXyzd50", skColorspaceAsFromXyzd50), DECLARE_NAPI_METHOD("skColorspaceIsNumericalTransferFn", skColorspaceIsNumericalTransferFn), DECLARE_NAPI_METHOD("skColorspaceprimariesToXyzd50", skColorspaceprimariesToXyzd50), DECLARE_NAPI_METHOD("skColorspaceTransferFnInvert", skColorspaceTransferFnInvert), DECLARE_NAPI_METHOD("skColorspaceTransferFnTransform", skColorspaceTransferFnTransform), DECLARE_NAPI_METHOD("skColortableUnref", skColortableUnref), DECLARE_NAPI_METHOD("skColortableNew", skColortableNew), DECLARE_NAPI_METHOD("skColortableCount", skColortableCount), DECLARE_NAPI_METHOD("skColortableReadColors", skColortableReadColors), DECLARE_NAPI_METHOD("skDataNewEmpty", skDataNewEmpty), DECLARE_NAPI_METHOD("skDataNewWithCopy", skDataNewWithCopy), DECLARE_NAPI_METHOD("skDataNewSubset", skDataNewSubset), DECLARE_NAPI_METHOD("skDataRef", skDataRef), DECLARE_NAPI_METHOD("skDataUnref", skDataUnref), DECLARE_NAPI_METHOD("skDataGetSize", skDataGetSize), DECLARE_NAPI_METHOD("skDataGetData", skDataGetData), DECLARE_NAPI_METHOD("skDataNewFromFile", skDataNewFromFile), DECLARE_NAPI_METHOD("skDataNewFromStream", skDataNewFromStream), DECLARE_NAPI_METHOD("skDataGetBytes", skDataGetBytes), DECLARE_NAPI_METHOD("skDataNewWithProc", skDataNewWithProc), DECLARE_NAPI_METHOD("skDataNewUninitialized", skDataNewUninitialized), DECLARE_NAPI_METHOD("skDocumentUnref", skDocumentUnref), DECLARE_NAPI_METHOD("skDocumentCreatePdfFromStream", skDocumentCreatePdfFromStream), DECLARE_NAPI_METHOD("skDocumentCreatePdfFromStreamWithMetadata", skDocumentCreatePdfFromStreamWithMetadata), DECLARE_NAPI_METHOD("skDocumentCreateXpsFromStream", skDocumentCreateXpsFromStream), DECLARE_NAPI_METHOD("skDocumentBeginPage", skDocumentBeginPage), DECLARE_NAPI_METHOD("skDocumentEndPage", skDocumentEndPage), DECLARE_NAPI_METHOD("skDocumentClose", skDocumentClose), DECLARE_NAPI_METHOD("skDocumentAbort", skDocumentAbort), DECLARE_NAPI_METHOD("skDrawableUnref", skDrawableUnref), DECLARE_NAPI_METHOD("skDrawableGetGenerationId", skDrawableGetGenerationId), DECLARE_NAPI_METHOD("skDrawableGetBounds", skDrawableGetBounds), DECLARE_NAPI_METHOD("skDrawableDraw", skDrawableDraw), DECLARE_NAPI_METHOD("skDrawableNewPictureSnapshot", skDrawableNewPictureSnapshot), DECLARE_NAPI_METHOD("skDrawableNotifyDrawingChanged", skDrawableNotifyDrawingChanged), DECLARE_NAPI_METHOD("skRefcntUnique", skRefcntUnique), DECLARE_NAPI_METHOD("skRefcntGetRefCount", skRefcntGetRefCount), DECLARE_NAPI_METHOD("skRefcntSafeRef", skRefcntSafeRef), DECLARE_NAPI_METHOD("skRefcntSafeUnref", skRefcntSafeUnref), DECLARE_NAPI_METHOD("skNvrefcntUnique", skNvrefcntUnique), DECLARE_NAPI_METHOD("skNvrefcntGetRefCount", skNvrefcntGetRefCount), DECLARE_NAPI_METHOD("skNvrefcntSafeRef", skNvrefcntSafeRef), DECLARE_NAPI_METHOD("skNvrefcntSafeUnref", skNvrefcntSafeUnref), DECLARE_NAPI_METHOD("skColortypeGetDefault_8888", skColortypeGetDefault_8888), DECLARE_NAPI_METHOD("skImageNewRasterCopy", skImageNewRasterCopy), DECLARE_NAPI_METHOD("skImageNewRasterCopyWithPixmap", skImageNewRasterCopyWithPixmap), DECLARE_NAPI_METHOD("skImageNewRasterData", skImageNewRasterData), DECLARE_NAPI_METHOD("skImageNewRaster", skImageNewRaster), DECLARE_NAPI_METHOD("skImageNewFromBitmap", skImageNewFromBitmap), DECLARE_NAPI_METHOD("skImageNewFromEncoded", skImageNewFromEncoded), DECLARE_NAPI_METHOD("skImageNewFromTexture", skImageNewFromTexture), DECLARE_NAPI_METHOD("skImageNewFromAdoptedTexture", skImageNewFromAdoptedTexture), DECLARE_NAPI_METHOD("skImageNewFromPicture", skImageNewFromPicture), DECLARE_NAPI_METHOD("skImageMakeSubset", skImageMakeSubset), DECLARE_NAPI_METHOD("skImageMakeNonTextureImage", skImageMakeNonTextureImage), DECLARE_NAPI_METHOD("skImageMakeWithFilter", skImageMakeWithFilter), DECLARE_NAPI_METHOD("skImageRef", skImageRef), DECLARE_NAPI_METHOD("skImageUnref", skImageUnref), DECLARE_NAPI_METHOD("skImageGetWidth", skImageGetWidth), DECLARE_NAPI_METHOD("skImageGetHeight", skImageGetHeight), DECLARE_NAPI_METHOD("skImageGetUniqueId", skImageGetUniqueId), DECLARE_NAPI_METHOD("skImageGetAlphaType", skImageGetAlphaType), DECLARE_NAPI_METHOD("skImageGetColorType", skImageGetColorType), DECLARE_NAPI_METHOD("skImageGetColorspace", skImageGetColorspace), DECLARE_NAPI_METHOD("skImageIsAlphaOnly", skImageIsAlphaOnly), DECLARE_NAPI_METHOD("skImageMakeShader", skImageMakeShader), DECLARE_NAPI_METHOD("skImagePeekPixels", skImagePeekPixels), DECLARE_NAPI_METHOD("skImageIsTextureBacked", skImageIsTextureBacked), DECLARE_NAPI_METHOD("skImageIsLazyGenerated", skImageIsLazyGenerated), DECLARE_NAPI_METHOD("skImageReadPixels", skImageReadPixels), DECLARE_NAPI_METHOD("skImageReadPixelsIntoPixmap", skImageReadPixelsIntoPixmap), DECLARE_NAPI_METHOD("skImageScalePixels", skImageScalePixels), DECLARE_NAPI_METHOD("skImageRefEncoded", skImageRefEncoded), DECLARE_NAPI_METHOD("skImageEncode", skImageEncode), DECLARE_NAPI_METHOD("skImageEncodeSpecific", skImageEncodeSpecific), DECLARE_NAPI_METHOD("skImagefilterCroprectNew", skImagefilterCroprectNew), DECLARE_NAPI_METHOD("skImagefilterCroprectNewWithRect", skImagefilterCroprectNewWithRect), DECLARE_NAPI_METHOD("skImagefilterCroprectDestructor", skImagefilterCroprectDestructor), DECLARE_NAPI_METHOD("skImagefilterCroprectGetRect", skImagefilterCroprectGetRect), DECLARE_NAPI_METHOD("skImagefilterCroprectGetFlags", skImagefilterCroprectGetFlags), DECLARE_NAPI_METHOD("skImagefilterUnref", skImagefilterUnref), DECLARE_NAPI_METHOD("skImagefilterNewMatrix", skImagefilterNewMatrix), DECLARE_NAPI_METHOD("skImagefilterNewAlphaThreshold", skImagefilterNewAlphaThreshold), DECLARE_NAPI_METHOD("skImagefilterNewBlur", skImagefilterNewBlur), DECLARE_NAPI_METHOD("skImagefilterNewColorFilter", skImagefilterNewColorFilter), DECLARE_NAPI_METHOD("skImagefilterNewCompose", skImagefilterNewCompose), DECLARE_NAPI_METHOD("skImagefilterNewDisplacementMapEffect", skImagefilterNewDisplacementMapEffect), DECLARE_NAPI_METHOD("skImagefilterNewDropShadow", skImagefilterNewDropShadow), DECLARE_NAPI_METHOD("skImagefilterNewDistantLitDiffuse", skImagefilterNewDistantLitDiffuse), DECLARE_NAPI_METHOD("skImagefilterNewPointLitDiffuse", skImagefilterNewPointLitDiffuse), DECLARE_NAPI_METHOD("skImagefilterNewSpotLitDiffuse", skImagefilterNewSpotLitDiffuse), DECLARE_NAPI_METHOD("skImagefilterNewDistantLitSpecular", skImagefilterNewDistantLitSpecular), DECLARE_NAPI_METHOD("skImagefilterNewPointLitSpecular", skImagefilterNewPointLitSpecular), DECLARE_NAPI_METHOD("skImagefilterNewSpotLitSpecular", skImagefilterNewSpotLitSpecular), DECLARE_NAPI_METHOD("skImagefilterNewMagnifier", skImagefilterNewMagnifier), DECLARE_NAPI_METHOD("skImagefilterNewMatrixConvolution", skImagefilterNewMatrixConvolution), DECLARE_NAPI_METHOD("skImagefilterNewMerge", skImagefilterNewMerge), DECLARE_NAPI_METHOD("skImagefilterNewDilate", skImagefilterNewDilate), DECLARE_NAPI_METHOD("skImagefilterNewErode", skImagefilterNewErode), DECLARE_NAPI_METHOD("skImagefilterNewOffset", skImagefilterNewOffset), DECLARE_NAPI_METHOD("skImagefilterNewPicture", skImagefilterNewPicture), DECLARE_NAPI_METHOD("skImagefilterNewPictureWithCroprect", skImagefilterNewPictureWithCroprect), DECLARE_NAPI_METHOD("skImagefilterNewTile", skImagefilterNewTile), DECLARE_NAPI_METHOD("skImagefilterNewXfermode", skImagefilterNewXfermode), DECLARE_NAPI_METHOD("skImagefilterNewArithmetic", skImagefilterNewArithmetic), DECLARE_NAPI_METHOD("skImagefilterNewImageSource", skImagefilterNewImageSource), DECLARE_NAPI_METHOD("skImagefilterNewImageSourceDefault", skImagefilterNewImageSourceDefault), DECLARE_NAPI_METHOD("skImagefilterNewPaint", skImagefilterNewPaint), DECLARE_NAPI_METHOD("skMaskAllocImage", skMaskAllocImage), DECLARE_NAPI_METHOD("skMaskFreeImage", skMaskFreeImage), DECLARE_NAPI_METHOD("skMaskIsEmpty", skMaskIsEmpty), DECLARE_NAPI_METHOD("skMaskComputeImageSize", skMaskComputeImageSize), DECLARE_NAPI_METHOD("skMaskComputeTotalImageSize", skMaskComputeTotalImageSize), DECLARE_NAPI_METHOD("skMaskGetAddr_1", skMaskGetAddr_1), DECLARE_NAPI_METHOD("skMaskGetAddr_8", skMaskGetAddr_8), DECLARE_NAPI_METHOD("skMaskGetAddrLcd_16", skMaskGetAddrLcd_16), DECLARE_NAPI_METHOD("skMaskGetAddr_32", skMaskGetAddr_32), DECLARE_NAPI_METHOD("skMaskGetAddr", skMaskGetAddr), DECLARE_NAPI_METHOD("skMaskfilterRef", skMaskfilterRef), DECLARE_NAPI_METHOD("skMaskfilterUnref", skMaskfilterUnref), DECLARE_NAPI_METHOD("skMaskfilterNewBlur", skMaskfilterNewBlur), DECLARE_NAPI_METHOD("skMaskfilterNewBlurWithFlags", skMaskfilterNewBlurWithFlags), DECLARE_NAPI_METHOD("skMaskfilterNewTable", skMaskfilterNewTable), DECLARE_NAPI_METHOD("skMaskfilterNewGamma", skMaskfilterNewGamma), DECLARE_NAPI_METHOD("skMaskfilterNewClip", skMaskfilterNewClip), DECLARE_NAPI_METHOD("skMatrixTryInvert", skMatrixTryInvert), DECLARE_NAPI_METHOD("skMatrixConcat", skMatrixConcat), DECLARE_NAPI_METHOD("skMatrixPreConcat", skMatrixPreConcat), DECLARE_NAPI_METHOD("skMatrixPostConcat", skMatrixPostConcat), DECLARE_NAPI_METHOD("skMatrixMapRect", skMatrixMapRect), DECLARE_NAPI_METHOD("skMatrixMapPoints", skMatrixMapPoints), DECLARE_NAPI_METHOD("skMatrixMapVectors", skMatrixMapVectors), DECLARE_NAPI_METHOD("skMatrixMapXy", skMatrixMapXy), DECLARE_NAPI_METHOD("skMatrixMapVector", skMatrixMapVector), DECLARE_NAPI_METHOD("skMatrixMapRadius", skMatrixMapRadius), DECLARE_NAPI_METHOD("sk_3dviewNew", sk_3dviewNew), DECLARE_NAPI_METHOD("sk_3dviewDestroy", sk_3dviewDestroy), DECLARE_NAPI_METHOD("sk_3dviewSave", sk_3dviewSave), DECLARE_NAPI_METHOD("sk_3dviewRestore", sk_3dviewRestore), DECLARE_NAPI_METHOD("sk_3dviewTranslate", sk_3dviewTranslate), DECLARE_NAPI_METHOD("sk_3dviewRotateXDegrees", sk_3dviewRotateXDegrees), DECLARE_NAPI_METHOD("sk_3dviewRotateYDegrees", sk_3dviewRotateYDegrees), DECLARE_NAPI_METHOD("sk_3dviewRotateZDegrees", sk_3dviewRotateZDegrees), DECLARE_NAPI_METHOD("sk_3dviewRotateXRadians", sk_3dviewRotateXRadians), DECLARE_NAPI_METHOD("sk_3dviewRotateYRadians", sk_3dviewRotateYRadians), DECLARE_NAPI_METHOD("sk_3dviewRotateZRadians", sk_3dviewRotateZRadians), DECLARE_NAPI_METHOD("sk_3dviewGetMatrix", sk_3dviewGetMatrix), DECLARE_NAPI_METHOD("sk_3dviewApplyToCanvas", sk_3dviewApplyToCanvas), DECLARE_NAPI_METHOD("sk_3dviewDotWithNormal", sk_3dviewDotWithNormal), DECLARE_NAPI_METHOD("skMatrix44Destroy", skMatrix44Destroy), DECLARE_NAPI_METHOD("skMatrix44New", skMatrix44New), DECLARE_NAPI_METHOD("skMatrix44NewIdentity", skMatrix44NewIdentity), DECLARE_NAPI_METHOD("skMatrix44NewCopy", skMatrix44NewCopy), DECLARE_NAPI_METHOD("skMatrix44NewConcat", skMatrix44NewConcat), DECLARE_NAPI_METHOD("skMatrix44NewMatrix", skMatrix44NewMatrix), DECLARE_NAPI_METHOD("skMatrix44Equals", skMatrix44Equals), DECLARE_NAPI_METHOD("skMatrix44ToMatrix", skMatrix44ToMatrix), DECLARE_NAPI_METHOD("skMatrix44GetType", skMatrix44GetType), DECLARE_NAPI_METHOD("skMatrix44SetIdentity", skMatrix44SetIdentity), DECLARE_NAPI_METHOD("skMatrix44Get", skMatrix44Get), DECLARE_NAPI_METHOD("skMatrix44Set", skMatrix44Set), DECLARE_NAPI_METHOD("skMatrix44AsColMajor", skMatrix44AsColMajor), DECLARE_NAPI_METHOD("skMatrix44AsRowMajor", skMatrix44AsRowMajor), DECLARE_NAPI_METHOD("skMatrix44SetColMajor", skMatrix44SetColMajor), DECLARE_NAPI_METHOD("skMatrix44SetRowMajor", skMatrix44SetRowMajor), DECLARE_NAPI_METHOD("skMatrix44SetTranslate", skMatrix44SetTranslate), DECLARE_NAPI_METHOD("skMatrix44PreTranslate", skMatrix44PreTranslate), DECLARE_NAPI_METHOD("skMatrix44PostTranslate", skMatrix44PostTranslate), DECLARE_NAPI_METHOD("skMatrix44SetScale", skMatrix44SetScale), DECLARE_NAPI_METHOD("skMatrix44PreScale", skMatrix44PreScale), DECLARE_NAPI_METHOD("skMatrix44PostScale", skMatrix44PostScale), DECLARE_NAPI_METHOD("skMatrix44SetRotateAboutDegrees", skMatrix44SetRotateAboutDegrees), DECLARE_NAPI_METHOD("skMatrix44SetRotateAboutRadians", skMatrix44SetRotateAboutRadians), DECLARE_NAPI_METHOD("skMatrix44SetRotateAboutRadiansUnit", skMatrix44SetRotateAboutRadiansUnit), DECLARE_NAPI_METHOD("skMatrix44SetConcat", skMatrix44SetConcat), DECLARE_NAPI_METHOD("skMatrix44PreConcat", skMatrix44PreConcat), DECLARE_NAPI_METHOD("skMatrix44PostConcat", skMatrix44PostConcat), DECLARE_NAPI_METHOD("skMatrix44Invert", skMatrix44Invert), DECLARE_NAPI_METHOD("skMatrix44Transpose", skMatrix44Transpose), DECLARE_NAPI_METHOD("skMatrix44MapScalars", skMatrix44MapScalars), DECLARE_NAPI_METHOD("skMatrix44Map2", skMatrix44Map2), DECLARE_NAPI_METHOD("skMatrix44Preserves_2dAxisAlignment", skMatrix44Preserves_2dAxisAlignment), DECLARE_NAPI_METHOD("skMatrix44Determinant", skMatrix44Determinant), DECLARE_NAPI_METHOD("skPaintNew", skPaintNew), DECLARE_NAPI_METHOD("skPaintClone", skPaintClone), DECLARE_NAPI_METHOD("skPaintDelete", skPaintDelete), DECLARE_NAPI_METHOD("skPaintReset", skPaintReset), DECLARE_NAPI_METHOD("skPaintIsAntialias", skPaintIsAntialias), DECLARE_NAPI_METHOD("skPaintSetAntialias", skPaintSetAntialias), DECLARE_NAPI_METHOD("skPaintGetColor", skPaintGetColor), DECLARE_NAPI_METHOD("skPaintSetColor", skPaintSetColor), DECLARE_NAPI_METHOD("skPaintGetStyle", skPaintGetStyle), DECLARE_NAPI_METHOD("skPaintSetStyle", skPaintSetStyle), DECLARE_NAPI_METHOD("skPaintGetStrokeWidth", skPaintGetStrokeWidth), DECLARE_NAPI_METHOD("skPaintSetStrokeWidth", skPaintSetStrokeWidth), DECLARE_NAPI_METHOD("skPaintGetStrokeMiter", skPaintGetStrokeMiter), DECLARE_NAPI_METHOD("skPaintSetStrokeMiter", skPaintSetStrokeMiter), DECLARE_NAPI_METHOD("skPaintGetStrokeCap", skPaintGetStrokeCap), DECLARE_NAPI_METHOD("skPaintSetStrokeCap", skPaintSetStrokeCap), DECLARE_NAPI_METHOD("skPaintGetStrokeJoin", skPaintGetStrokeJoin), DECLARE_NAPI_METHOD("skPaintSetStrokeJoin", skPaintSetStrokeJoin), DECLARE_NAPI_METHOD("skPaintSetShader", skPaintSetShader), DECLARE_NAPI_METHOD("skPaintSetMaskfilter", skPaintSetMaskfilter), DECLARE_NAPI_METHOD("skPaintSetBlendmode", skPaintSetBlendmode), DECLARE_NAPI_METHOD("skPaintIsDither", skPaintIsDither), DECLARE_NAPI_METHOD("skPaintSetDither", skPaintSetDither), DECLARE_NAPI_METHOD("skPaintIsVerticaltext", skPaintIsVerticaltext), DECLARE_NAPI_METHOD("skPaintSetVerticaltext", skPaintSetVerticaltext), DECLARE_NAPI_METHOD("skPaintGetShader", skPaintGetShader), DECLARE_NAPI_METHOD("skPaintGetMaskfilter", skPaintGetMaskfilter), DECLARE_NAPI_METHOD("skPaintSetColorfilter", skPaintSetColorfilter), DECLARE_NAPI_METHOD("skPaintGetColorfilter", skPaintGetColorfilter), DECLARE_NAPI_METHOD("skPaintSetImagefilter", skPaintSetImagefilter), DECLARE_NAPI_METHOD("skPaintGetImagefilter", skPaintGetImagefilter), DECLARE_NAPI_METHOD("skPaintGetBlendmode", skPaintGetBlendmode), DECLARE_NAPI_METHOD("skPaintSetFilterQuality", skPaintSetFilterQuality), DECLARE_NAPI_METHOD("skPaintGetFilterQuality", skPaintGetFilterQuality), DECLARE_NAPI_METHOD("skPaintGetTypeface", skPaintGetTypeface), DECLARE_NAPI_METHOD("skPaintSetTypeface", skPaintSetTypeface), DECLARE_NAPI_METHOD("skPaintGetTextsize", skPaintGetTextsize), DECLARE_NAPI_METHOD("skPaintSetTextsize", skPaintSetTextsize), DECLARE_NAPI_METHOD("skPaintGetTextAlign", skPaintGetTextAlign), DECLARE_NAPI_METHOD("skPaintSetTextAlign", skPaintSetTextAlign), DECLARE_NAPI_METHOD("skPaintGetTextEncoding", skPaintGetTextEncoding), DECLARE_NAPI_METHOD("skPaintSetTextEncoding", skPaintSetTextEncoding), DECLARE_NAPI_METHOD("skPaintGetTextScaleX", skPaintGetTextScaleX), DECLARE_NAPI_METHOD("skPaintSetTextScaleX", skPaintSetTextScaleX), DECLARE_NAPI_METHOD("skPaintGetTextSkewX", skPaintGetTextSkewX), DECLARE_NAPI_METHOD("skPaintSetTextSkewX", skPaintSetTextSkewX), DECLARE_NAPI_METHOD("skPaintBreakText", skPaintBreakText), DECLARE_NAPI_METHOD("skPaintMeasureText", skPaintMeasureText), DECLARE_NAPI_METHOD("skPaintGetTextPath", skPaintGetTextPath), DECLARE_NAPI_METHOD("skPaintGetPosTextPath", skPaintGetPosTextPath), DECLARE_NAPI_METHOD("skPaintGetFontmetrics", skPaintGetFontmetrics), DECLARE_NAPI_METHOD("skPaintGetPathEffect", skPaintGetPathEffect), DECLARE_NAPI_METHOD("skPaintSetPathEffect", skPaintSetPathEffect), DECLARE_NAPI_METHOD("skPaintIsLinearText", skPaintIsLinearText), DECLARE_NAPI_METHOD("skPaintSetLinearText", skPaintSetLinearText), DECLARE_NAPI_METHOD("skPaintIsSubpixelText", skPaintIsSubpixelText), DECLARE_NAPI_METHOD("skPaintSetSubpixelText", skPaintSetSubpixelText), DECLARE_NAPI_METHOD("skPaintIsLcdRenderText", skPaintIsLcdRenderText), DECLARE_NAPI_METHOD("skPaintSetLcdRenderText", skPaintSetLcdRenderText), DECLARE_NAPI_METHOD("skPaintIsEmbeddedBitmapText", skPaintIsEmbeddedBitmapText), DECLARE_NAPI_METHOD("skPaintSetEmbeddedBitmapText", skPaintSetEmbeddedBitmapText), DECLARE_NAPI_METHOD("skPaintGetHinting", skPaintGetHinting), DECLARE_NAPI_METHOD("skPaintSetHinting", skPaintSetHinting), DECLARE_NAPI_METHOD("skPaintIsAutohinted", skPaintIsAutohinted), DECLARE_NAPI_METHOD("skPaintSetAutohinted", skPaintSetAutohinted), DECLARE_NAPI_METHOD("skPaintIsFakeBoldText", skPaintIsFakeBoldText), DECLARE_NAPI_METHOD("skPaintSetFakeBoldText", skPaintSetFakeBoldText), DECLARE_NAPI_METHOD("skPaintIsDevKernText", skPaintIsDevKernText), DECLARE_NAPI_METHOD("skPaintSetDevKernText", skPaintSetDevKernText), DECLARE_NAPI_METHOD("skPaintGetFillPath", skPaintGetFillPath), DECLARE_NAPI_METHOD("skPaintTextToGlyphs", skPaintTextToGlyphs), DECLARE_NAPI_METHOD("skPaintContainsText", skPaintContainsText), DECLARE_NAPI_METHOD("skPaintCountText", skPaintCountText), DECLARE_NAPI_METHOD("skPaintGetTextWidths", skPaintGetTextWidths), DECLARE_NAPI_METHOD("skPaintGetTextIntercepts", skPaintGetTextIntercepts), DECLARE_NAPI_METHOD("skPaintGetPosTextIntercepts", skPaintGetPosTextIntercepts), DECLARE_NAPI_METHOD("skPaintGetPosTextHIntercepts", skPaintGetPosTextHIntercepts), DECLARE_NAPI_METHOD("skPaintGetPosTextBlobIntercepts", skPaintGetPosTextBlobIntercepts), DECLARE_NAPI_METHOD("skPathNew", skPathNew), DECLARE_NAPI_METHOD("skPathDelete", skPathDelete), DECLARE_NAPI_METHOD("skPathMoveTo", skPathMoveTo), DECLARE_NAPI_METHOD("skPathLineTo", skPathLineTo), DECLARE_NAPI_METHOD("skPathQuadTo", skPathQuadTo), DECLARE_NAPI_METHOD("skPathConicTo", skPathConicTo), DECLARE_NAPI_METHOD("skPathCubicTo", skPathCubicTo), DECLARE_NAPI_METHOD("skPathArcTo", skPathArcTo), DECLARE_NAPI_METHOD("skPathRarcTo", skPathRarcTo), DECLARE_NAPI_METHOD("skPathArcToWithOval", skPathArcToWithOval), DECLARE_NAPI_METHOD("skPathArcToWithPoints", skPathArcToWithPoints), DECLARE_NAPI_METHOD("skPathClose", skPathClose), DECLARE_NAPI_METHOD("skPathAddRect", skPathAddRect), DECLARE_NAPI_METHOD("skPathAddRrect", skPathAddRrect), DECLARE_NAPI_METHOD("skPathAddRrectStart", skPathAddRrectStart), DECLARE_NAPI_METHOD("skPathAddRoundedRect", skPathAddRoundedRect), DECLARE_NAPI_METHOD("skPathAddOval", skPathAddOval), DECLARE_NAPI_METHOD("skPathAddCircle", skPathAddCircle), DECLARE_NAPI_METHOD("skPathGetBounds", skPathGetBounds), DECLARE_NAPI_METHOD("skPathComputeTightBounds", skPathComputeTightBounds), DECLARE_NAPI_METHOD("skPathRmoveTo", skPathRmoveTo), DECLARE_NAPI_METHOD("skPathRlineTo", skPathRlineTo), DECLARE_NAPI_METHOD("skPathRquadTo", skPathRquadTo), DECLARE_NAPI_METHOD("skPathRconicTo", skPathRconicTo), DECLARE_NAPI_METHOD("skPathRcubicTo", skPathRcubicTo), DECLARE_NAPI_METHOD("skPathAddRectStart", skPathAddRectStart), DECLARE_NAPI_METHOD("skPathAddArc", skPathAddArc), DECLARE_NAPI_METHOD("skPathGetFilltype", skPathGetFilltype), DECLARE_NAPI_METHOD("skPathSetFilltype", skPathSetFilltype), DECLARE_NAPI_METHOD("skPathTransform", skPathTransform), DECLARE_NAPI_METHOD("skPathClone", skPathClone), DECLARE_NAPI_METHOD("skPathAddPathOffset", skPathAddPathOffset), DECLARE_NAPI_METHOD("skPathAddPathMatrix", skPathAddPathMatrix), DECLARE_NAPI_METHOD("skPathAddPath", skPathAddPath), DECLARE_NAPI_METHOD("skPathAddPathReverse", skPathAddPathReverse), DECLARE_NAPI_METHOD("skPathReset", skPathReset), DECLARE_NAPI_METHOD("skPathRewind", skPathRewind), DECLARE_NAPI_METHOD("skPathCountPoints", skPathCountPoints), DECLARE_NAPI_METHOD("skPathCountVerbs", skPathCountVerbs), DECLARE_NAPI_METHOD("skPathGetPoint", skPathGetPoint), DECLARE_NAPI_METHOD("skPathGetPoints", skPathGetPoints), DECLARE_NAPI_METHOD("skPathContains", skPathContains), DECLARE_NAPI_METHOD("skPathGetConvexity", skPathGetConvexity), DECLARE_NAPI_METHOD("skPathSetConvexity", skPathSetConvexity), DECLARE_NAPI_METHOD("skPathParseSvgString", skPathParseSvgString), DECLARE_NAPI_METHOD("skPathToSvgString", skPathToSvgString), DECLARE_NAPI_METHOD("skPathGetLastPoint", skPathGetLastPoint), DECLARE_NAPI_METHOD("skPathConvertConicToQuads", skPathConvertConicToQuads), DECLARE_NAPI_METHOD("skPathAddPoly", skPathAddPoly), DECLARE_NAPI_METHOD("skPathGetSegmentMasks", skPathGetSegmentMasks), DECLARE_NAPI_METHOD("skPathIsOval", skPathIsOval), DECLARE_NAPI_METHOD("skPathIsRrect", skPathIsRrect), DECLARE_NAPI_METHOD("skPathIsLine", skPathIsLine), DECLARE_NAPI_METHOD("skPathIsRect", skPathIsRect), DECLARE_NAPI_METHOD("skPathCreateIter", skPathCreateIter), DECLARE_NAPI_METHOD("skPathIterNext", skPathIterNext), DECLARE_NAPI_METHOD("skPathIterConicWeight", skPathIterConicWeight), DECLARE_NAPI_METHOD("skPathIterIsCloseLine", skPathIterIsCloseLine), DECLARE_NAPI_METHOD("skPathIterIsClosedContour", skPathIterIsClosedContour), DECLARE_NAPI_METHOD("skPathIterDestroy", skPathIterDestroy), DECLARE_NAPI_METHOD("skPathCreateRawiter", skPathCreateRawiter), DECLARE_NAPI_METHOD("skPathRawiterPeek", skPathRawiterPeek), DECLARE_NAPI_METHOD("skPathRawiterNext", skPathRawiterNext), DECLARE_NAPI_METHOD("skPathRawiterConicWeight", skPathRawiterConicWeight), DECLARE_NAPI_METHOD("skPathRawiterDestroy", skPathRawiterDestroy), DECLARE_NAPI_METHOD("skPathopOp", skPathopOp), DECLARE_NAPI_METHOD("skPathopSimplify", skPathopSimplify), DECLARE_NAPI_METHOD("skPathopTightBounds", skPathopTightBounds), DECLARE_NAPI_METHOD("skOpbuilderNew", skOpbuilderNew), DECLARE_NAPI_METHOD("skOpbuilderDestroy", skOpbuilderDestroy), DECLARE_NAPI_METHOD("skOpbuilderAdd", skOpbuilderAdd), DECLARE_NAPI_METHOD("skOpbuilderResolve", skOpbuilderResolve), DECLARE_NAPI_METHOD("skPathmeasureNew", skPathmeasureNew), DECLARE_NAPI_METHOD("skPathmeasureNewWithPath", skPathmeasureNewWithPath), DECLARE_NAPI_METHOD("skPathmeasureDestroy", skPathmeasureDestroy), DECLARE_NAPI_METHOD("skPathmeasureSetPath", skPathmeasureSetPath), DECLARE_NAPI_METHOD("skPathmeasureGetLength", skPathmeasureGetLength), DECLARE_NAPI_METHOD("skPathmeasureGetPosTan", skPathmeasureGetPosTan), DECLARE_NAPI_METHOD("skPathmeasureGetMatrix", skPathmeasureGetMatrix), DECLARE_NAPI_METHOD("skPathmeasureGetSegment", skPathmeasureGetSegment), DECLARE_NAPI_METHOD("skPathmeasureIsClosed", skPathmeasureIsClosed), DECLARE_NAPI_METHOD("skPathmeasureNextContour", skPathmeasureNextContour), DECLARE_NAPI_METHOD("skPathEffectUnref", skPathEffectUnref), DECLARE_NAPI_METHOD("skPathEffectCreateCompose", skPathEffectCreateCompose), DECLARE_NAPI_METHOD("skPathEffectCreateSum", skPathEffectCreateSum), DECLARE_NAPI_METHOD("skPathEffectCreateDiscrete", skPathEffectCreateDiscrete), DECLARE_NAPI_METHOD("skPathEffectCreateCorner", skPathEffectCreateCorner), DECLARE_NAPI_METHOD("skPathEffectCreate_1dPath", skPathEffectCreate_1dPath), DECLARE_NAPI_METHOD("skPathEffectCreate_2dLine", skPathEffectCreate_2dLine), DECLARE_NAPI_METHOD("skPathEffectCreate_2dPath", skPathEffectCreate_2dPath), DECLARE_NAPI_METHOD("skPathEffectCreateDash", skPathEffectCreateDash), DECLARE_NAPI_METHOD("skPathEffectCreateTrim", skPathEffectCreateTrim), DECLARE_NAPI_METHOD("skPictureRecorderNew", skPictureRecorderNew), DECLARE_NAPI_METHOD("skPictureRecorderDelete", skPictureRecorderDelete), DECLARE_NAPI_METHOD("skPictureRecorderBeginRecording", skPictureRecorderBeginRecording), DECLARE_NAPI_METHOD("skPictureRecorderEndRecording", skPictureRecorderEndRecording), DECLARE_NAPI_METHOD("skPictureRecorderEndRecordingAsDrawable", skPictureRecorderEndRecordingAsDrawable), DECLARE_NAPI_METHOD("skPictureGetRecordingCanvas", skPictureGetRecordingCanvas), DECLARE_NAPI_METHOD("skPictureRef", skPictureRef), DECLARE_NAPI_METHOD("skPictureUnref", skPictureUnref), DECLARE_NAPI_METHOD("skPictureGetUniqueId", skPictureGetUniqueId), DECLARE_NAPI_METHOD("skPictureGetCullRect", skPictureGetCullRect), DECLARE_NAPI_METHOD("skPixmapDestructor", skPixmapDestructor), DECLARE_NAPI_METHOD("skPixmapNew", skPixmapNew), DECLARE_NAPI_METHOD("skPixmapNewWithParams", skPixmapNewWithParams), DECLARE_NAPI_METHOD("skPixmapReset", skPixmapReset), DECLARE_NAPI_METHOD("skPixmapResetWithParams", skPixmapResetWithParams), DECLARE_NAPI_METHOD("skPixmapGetInfo", skPixmapGetInfo), DECLARE_NAPI_METHOD("skPixmapGetRowBytes", skPixmapGetRowBytes), DECLARE_NAPI_METHOD("skPixmapGetPixels", skPixmapGetPixels), DECLARE_NAPI_METHOD("skPixmapGetPixelsWithXy", skPixmapGetPixelsWithXy), DECLARE_NAPI_METHOD("skPixmapGetPixelColor", skPixmapGetPixelColor), DECLARE_NAPI_METHOD("skPixmapEncodeImage", skPixmapEncodeImage), DECLARE_NAPI_METHOD("skPixmapReadPixels", skPixmapReadPixels), DECLARE_NAPI_METHOD("skPixmapScalePixels", skPixmapScalePixels), DECLARE_NAPI_METHOD("skPixmapExtractSubset", skPixmapExtractSubset), DECLARE_NAPI_METHOD("skPixmapEraseColor", skPixmapEraseColor), DECLARE_NAPI_METHOD("skColorUnpremultiply", skColorUnpremultiply), DECLARE_NAPI_METHOD("skColorPremultiply", skColorPremultiply), DECLARE_NAPI_METHOD("skColorUnpremultiplyArray", skColorUnpremultiplyArray), DECLARE_NAPI_METHOD("skColorPremultiplyArray", skColorPremultiplyArray), DECLARE_NAPI_METHOD("skColorGetBitShift", skColorGetBitShift), DECLARE_NAPI_METHOD("skSwizzleSwapRb", skSwizzleSwapRb), DECLARE_NAPI_METHOD("skWebpencoderEncode", skWebpencoderEncode), DECLARE_NAPI_METHOD("skJpegencoderEncode", skJpegencoderEncode), DECLARE_NAPI_METHOD("skPngencoderEncode", skPngencoderEncode), DECLARE_NAPI_METHOD("skRegionNew", skRegionNew), DECLARE_NAPI_METHOD("skRegionNew2", skRegionNew2), DECLARE_NAPI_METHOD("skRegionDelete", skRegionDelete), DECLARE_NAPI_METHOD("skRegionContains", skRegionContains), DECLARE_NAPI_METHOD("skRegionContains2", skRegionContains2), DECLARE_NAPI_METHOD("skRegionIntersectsRect", skRegionIntersectsRect), DECLARE_NAPI_METHOD("skRegionIntersects", skRegionIntersects), DECLARE_NAPI_METHOD("skRegionSetPath", skRegionSetPath), DECLARE_NAPI_METHOD("skRegionSetRect", skRegionSetRect), DECLARE_NAPI_METHOD("skRegionSetRegion", skRegionSetRegion), DECLARE_NAPI_METHOD("skRegionOp", skRegionOp), DECLARE_NAPI_METHOD("skRegionOp2", skRegionOp2), DECLARE_NAPI_METHOD("skRegionGetBounds", skRegionGetBounds), DECLARE_NAPI_METHOD("skRrectNew", skRrectNew), DECLARE_NAPI_METHOD("skRrectNewCopy", skRrectNewCopy), DECLARE_NAPI_METHOD("skRrectDelete", skRrectDelete), DECLARE_NAPI_METHOD("skRrectGetType", skRrectGetType), DECLARE_NAPI_METHOD("skRrectGetRect", skRrectGetRect), DECLARE_NAPI_METHOD("skRrectGetRadii", skRrectGetRadii), DECLARE_NAPI_METHOD("skRrectGetWidth", skRrectGetWidth), DECLARE_NAPI_METHOD("skRrectGetHeight", skRrectGetHeight), DECLARE_NAPI_METHOD("skRrectSetEmpty", skRrectSetEmpty), DECLARE_NAPI_METHOD("skRrectSetRect", skRrectSetRect), DECLARE_NAPI_METHOD("skRrectSetOval", skRrectSetOval), DECLARE_NAPI_METHOD("skRrectSetRectXy", skRrectSetRectXy), DECLARE_NAPI_METHOD("skRrectSetNinePatch", skRrectSetNinePatch), DECLARE_NAPI_METHOD("skRrectSetRectRadii", skRrectSetRectRadii), DECLARE_NAPI_METHOD("skRrectInset", skRrectInset), DECLARE_NAPI_METHOD("skRrectOutset", skRrectOutset), DECLARE_NAPI_METHOD("skRrectOffset", skRrectOffset), DECLARE_NAPI_METHOD("skRrectContains", skRrectContains), DECLARE_NAPI_METHOD("skRrectIsValid", skRrectIsValid), DECLARE_NAPI_METHOD("skRrectTransform", skRrectTransform), DECLARE_NAPI_METHOD("skShaderRef", skShaderRef), DECLARE_NAPI_METHOD("skShaderUnref", skShaderUnref), DECLARE_NAPI_METHOD("skShaderNewLinearGradient", skShaderNewLinearGradient), DECLARE_NAPI_METHOD("skShaderNewRadialGradient", skShaderNewRadialGradient), DECLARE_NAPI_METHOD("skShaderNewSweepGradient", skShaderNewSweepGradient), DECLARE_NAPI_METHOD("skShaderNewTwoPointConicalGradient", skShaderNewTwoPointConicalGradient), DECLARE_NAPI_METHOD("skShaderNewEmpty", skShaderNewEmpty), DECLARE_NAPI_METHOD("skShaderNewColor", skShaderNewColor), DECLARE_NAPI_METHOD("skShaderNewBitmap", skShaderNewBitmap), DECLARE_NAPI_METHOD("skShaderNewPicture", skShaderNewPicture), DECLARE_NAPI_METHOD("skShaderNewLocalMatrix", skShaderNewLocalMatrix), DECLARE_NAPI_METHOD("skShaderNewColorFilter", skShaderNewColorFilter), DECLARE_NAPI_METHOD("skShaderNewPerlinNoiseFractalNoise", skShaderNewPerlinNoiseFractalNoise), DECLARE_NAPI_METHOD("skShaderNewPerlinNoiseTurbulence", skShaderNewPerlinNoiseTurbulence), DECLARE_NAPI_METHOD("skShaderNewPerlinNoiseImprovedNoise", skShaderNewPerlinNoiseImprovedNoise), DECLARE_NAPI_METHOD("skShaderNewCompose", skShaderNewCompose), DECLARE_NAPI_METHOD("skShaderNewComposeWithMode", skShaderNewComposeWithMode), DECLARE_NAPI_METHOD("skStreamAssetDestroy", skStreamAssetDestroy), DECLARE_NAPI_METHOD("skFilestreamNew", skFilestreamNew), DECLARE_NAPI_METHOD("skFilestreamDestroy", skFilestreamDestroy), DECLARE_NAPI_METHOD("skFilestreamIsValid", skFilestreamIsValid), DECLARE_NAPI_METHOD("skMemorystreamNew", skMemorystreamNew), DECLARE_NAPI_METHOD("skMemorystreamNewWithLength", skMemorystreamNewWithLength), DECLARE_NAPI_METHOD("skMemorystreamNewWithData", skMemorystreamNewWithData), DECLARE_NAPI_METHOD("skMemorystreamNewWithSkdata", skMemorystreamNewWithSkdata), DECLARE_NAPI_METHOD("skMemorystreamSetMemory", skMemorystreamSetMemory), DECLARE_NAPI_METHOD("skMemorystreamDestroy", skMemorystreamDestroy), DECLARE_NAPI_METHOD("skStreamRead", skStreamRead), DECLARE_NAPI_METHOD("skStreamPeek", skStreamPeek), DECLARE_NAPI_METHOD("skStreamSkip", skStreamSkip), DECLARE_NAPI_METHOD("skStreamIsAtEnd", skStreamIsAtEnd), DECLARE_NAPI_METHOD("skStreamReadS8", skStreamReadS8), DECLARE_NAPI_METHOD("skStreamReadS16", skStreamReadS16), DECLARE_NAPI_METHOD("skStreamReadS32", skStreamReadS32), DECLARE_NAPI_METHOD("skStreamReadU8", skStreamReadU8), DECLARE_NAPI_METHOD("skStreamReadU16", skStreamReadU16), DECLARE_NAPI_METHOD("skStreamReadU32", skStreamReadU32), DECLARE_NAPI_METHOD("skStreamReadBool", skStreamReadBool), DECLARE_NAPI_METHOD("skStreamRewind", skStreamRewind), DECLARE_NAPI_METHOD("skStreamHasPosition", skStreamHasPosition), DECLARE_NAPI_METHOD("skStreamGetPosition", skStreamGetPosition), DECLARE_NAPI_METHOD("skStreamSeek", skStreamSeek), DECLARE_NAPI_METHOD("skStreamMove", skStreamMove), DECLARE_NAPI_METHOD("skStreamHasLength", skStreamHasLength), DECLARE_NAPI_METHOD("skStreamGetLength", skStreamGetLength), DECLARE_NAPI_METHOD("skStreamGetMemoryBase", skStreamGetMemoryBase), DECLARE_NAPI_METHOD("skStreamFork", skStreamFork), DECLARE_NAPI_METHOD("skStreamDuplicate", skStreamDuplicate), DECLARE_NAPI_METHOD("skStreamDestroy", skStreamDestroy), DECLARE_NAPI_METHOD("skFilewstreamNew", skFilewstreamNew), DECLARE_NAPI_METHOD("skFilewstreamDestroy", skFilewstreamDestroy), DECLARE_NAPI_METHOD("skFilewstreamIsValid", skFilewstreamIsValid), DECLARE_NAPI_METHOD("skDynamicmemorywstreamNew", skDynamicmemorywstreamNew), DECLARE_NAPI_METHOD("skDynamicmemorywstreamDetachAsStream", skDynamicmemorywstreamDetachAsStream), DECLARE_NAPI_METHOD("skDynamicmemorywstreamDetachAsData", skDynamicmemorywstreamDetachAsData), DECLARE_NAPI_METHOD("skDynamicmemorywstreamCopyTo", skDynamicmemorywstreamCopyTo), DECLARE_NAPI_METHOD("skDynamicmemorywstreamWriteToStream", skDynamicmemorywstreamWriteToStream), DECLARE_NAPI_METHOD("skDynamicmemorywstreamDestroy", skDynamicmemorywstreamDestroy), DECLARE_NAPI_METHOD("skWstreamWrite", skWstreamWrite), DECLARE_NAPI_METHOD("skWstreamNewline", skWstreamNewline), DECLARE_NAPI_METHOD("skWstreamFlush", skWstreamFlush), DECLARE_NAPI_METHOD("skWstreamBytesWritten", skWstreamBytesWritten), DECLARE_NAPI_METHOD("skWstreamWrite_8", skWstreamWrite_8), DECLARE_NAPI_METHOD("skWstreamWrite_16", skWstreamWrite_16), DECLARE_NAPI_METHOD("skWstreamWrite_32", skWstreamWrite_32), DECLARE_NAPI_METHOD("skWstreamWriteText", skWstreamWriteText), DECLARE_NAPI_METHOD("skWstreamWriteDecAsText", skWstreamWriteDecAsText), DECLARE_NAPI_METHOD("skWstreamWriteBigdecAsText", skWstreamWriteBigdecAsText), DECLARE_NAPI_METHOD("skWstreamWriteHexAsText", skWstreamWriteHexAsText), DECLARE_NAPI_METHOD("skWstreamWriteScalarAsText", skWstreamWriteScalarAsText), DECLARE_NAPI_METHOD("skWstreamWriteBool", skWstreamWriteBool), DECLARE_NAPI_METHOD("skWstreamWriteScalar", skWstreamWriteScalar), DECLARE_NAPI_METHOD("skWstreamWritePackedUint", skWstreamWritePackedUint), DECLARE_NAPI_METHOD("skWstreamWriteStream", skWstreamWriteStream), DECLARE_NAPI_METHOD("skWstreamGetSizeOfPackedUint", skWstreamGetSizeOfPackedUint), DECLARE_NAPI_METHOD("skStringNewEmpty", skStringNewEmpty), DECLARE_NAPI_METHOD("skStringNewWithCopy", skStringNewWithCopy), DECLARE_NAPI_METHOD("skStringDestructor", skStringDestructor), DECLARE_NAPI_METHOD("skStringGetSize", skStringGetSize), DECLARE_NAPI_METHOD("skStringGetCStr", skStringGetCStr), DECLARE_NAPI_METHOD("skSurfaceNewNull", skSurfaceNewNull), DECLARE_NAPI_METHOD("skSurfaceNewRaster", skSurfaceNewRaster), DECLARE_NAPI_METHOD("skSurfaceNewRasterDirect", skSurfaceNewRasterDirect), DECLARE_NAPI_METHOD("skSurfaceNewBackendTexture", skSurfaceNewBackendTexture), DECLARE_NAPI_METHOD("skSurfaceNewBackendRenderTarget", skSurfaceNewBackendRenderTarget), DECLARE_NAPI_METHOD("skSurfaceNewBackendTextureAsRenderTarget", skSurfaceNewBackendTextureAsRenderTarget), DECLARE_NAPI_METHOD("skSurfaceNewRenderTarget", skSurfaceNewRenderTarget), DECLARE_NAPI_METHOD("skSurfaceUnref", skSurfaceUnref), DECLARE_NAPI_METHOD("skSurfaceGetCanvas", skSurfaceGetCanvas), DECLARE_NAPI_METHOD("skSurfaceNewImageSnapshot", skSurfaceNewImageSnapshot), DECLARE_NAPI_METHOD("skSurfaceDraw", skSurfaceDraw), DECLARE_NAPI_METHOD("skSurfacePeekPixels", skSurfacePeekPixels), DECLARE_NAPI_METHOD("skSurfaceReadPixels", skSurfaceReadPixels), DECLARE_NAPI_METHOD("skSurfaceGetProps", skSurfaceGetProps), DECLARE_NAPI_METHOD("skSurfacepropsNew", skSurfacepropsNew), DECLARE_NAPI_METHOD("skSurfacepropsDelete", skSurfacepropsDelete), DECLARE_NAPI_METHOD("skSurfacepropsGetFlags", skSurfacepropsGetFlags), DECLARE_NAPI_METHOD("skSurfacepropsGetPixelGeometry", skSurfacepropsGetPixelGeometry), DECLARE_NAPI_METHOD("skSvgcanvasCreate", skSvgcanvasCreate), DECLARE_NAPI_METHOD("skTextblobRef", skTextblobRef), DECLARE_NAPI_METHOD("skTextblobUnref", skTextblobUnref), DECLARE_NAPI_METHOD("skTextblobGetUniqueId", skTextblobGetUniqueId), DECLARE_NAPI_METHOD("skTextblobGetBounds", skTextblobGetBounds), DECLARE_NAPI_METHOD("skTextblobBuilderNew", skTextblobBuilderNew), DECLARE_NAPI_METHOD("skTextblobBuilderDelete", skTextblobBuilderDelete), DECLARE_NAPI_METHOD("skTextblobBuilderMake", skTextblobBuilderMake), DECLARE_NAPI_METHOD("skTextblobBuilderAllocRunText", skTextblobBuilderAllocRunText), DECLARE_NAPI_METHOD("skTextblobBuilderAllocRunTextPosH", skTextblobBuilderAllocRunTextPosH), DECLARE_NAPI_METHOD("skTextblobBuilderAllocRunTextPos", skTextblobBuilderAllocRunTextPos), DECLARE_NAPI_METHOD("skTypefaceCreateDefault", skTypefaceCreateDefault), DECLARE_NAPI_METHOD("skTypefaceRefDefault", skTypefaceRefDefault), DECLARE_NAPI_METHOD("skTypefaceCreateFromNameWithFontStyle", skTypefaceCreateFromNameWithFontStyle), DECLARE_NAPI_METHOD("skTypefaceUnref", skTypefaceUnref), DECLARE_NAPI_METHOD("skTypefaceCreateFromFile", skTypefaceCreateFromFile), DECLARE_NAPI_METHOD("skTypefaceCreateFromStream", skTypefaceCreateFromStream), DECLARE_NAPI_METHOD("skTypefaceCharsToGlyphs", skTypefaceCharsToGlyphs), DECLARE_NAPI_METHOD("skTypefaceOpenStream", skTypefaceOpenStream), DECLARE_NAPI_METHOD("skTypefaceGetUnitsPerEm", skTypefaceGetUnitsPerEm), DECLARE_NAPI_METHOD("skTypefaceGetFamilyName", skTypefaceGetFamilyName), DECLARE_NAPI_METHOD("skTypefaceGetFontstyle", skTypefaceGetFontstyle), DECLARE_NAPI_METHOD("skTypefaceGetFontWeight", skTypefaceGetFontWeight), DECLARE_NAPI_METHOD("skTypefaceGetFontWidth", skTypefaceGetFontWidth), DECLARE_NAPI_METHOD("skTypefaceGetFontSlant", skTypefaceGetFontSlant), DECLARE_NAPI_METHOD("skTypefaceCountTables", skTypefaceCountTables), DECLARE_NAPI_METHOD("skTypefaceGetTableTags", skTypefaceGetTableTags), DECLARE_NAPI_METHOD("skTypefaceGetTableSize", skTypefaceGetTableSize), DECLARE_NAPI_METHOD("skTypefaceGetTableData", skTypefaceGetTableData), DECLARE_NAPI_METHOD("skTypefaceIsFixedPitch", skTypefaceIsFixedPitch), DECLARE_NAPI_METHOD("skFontmgrCreateDefault", skFontmgrCreateDefault), DECLARE_NAPI_METHOD("skFontmgrRefDefault", skFontmgrRefDefault), DECLARE_NAPI_METHOD("skFontmgrUnref", skFontmgrUnref), DECLARE_NAPI_METHOD("skFontmgrCountFamilies", skFontmgrCountFamilies), DECLARE_NAPI_METHOD("skFontmgrGetFamilyName", skFontmgrGetFamilyName), DECLARE_NAPI_METHOD("skFontmgrCreateStyleset", skFontmgrCreateStyleset), DECLARE_NAPI_METHOD("skFontmgrMatchFamily", skFontmgrMatchFamily), DECLARE_NAPI_METHOD("skFontmgrMatchFamilyStyle", skFontmgrMatchFamilyStyle), DECLARE_NAPI_METHOD("skFontmgrMatchFamilyStyleCharacter", skFontmgrMatchFamilyStyleCharacter), DECLARE_NAPI_METHOD("skFontmgrMatchFaceStyle", skFontmgrMatchFaceStyle), DECLARE_NAPI_METHOD("skFontmgrCreateFromData", skFontmgrCreateFromData), DECLARE_NAPI_METHOD("skFontmgrCreateFromStream", skFontmgrCreateFromStream), DECLARE_NAPI_METHOD("skFontmgrCreateFromFile", skFontmgrCreateFromFile), DECLARE_NAPI_METHOD("skFontstyleNew", skFontstyleNew), DECLARE_NAPI_METHOD("skFontstyleDelete", skFontstyleDelete), DECLARE_NAPI_METHOD("skFontstyleGetWeight", skFontstyleGetWeight), DECLARE_NAPI_METHOD("skFontstyleGetWidth", skFontstyleGetWidth), DECLARE_NAPI_METHOD("skFontstyleGetSlant", skFontstyleGetSlant), DECLARE_NAPI_METHOD("skFontstylesetCreateEmpty", skFontstylesetCreateEmpty), DECLARE_NAPI_METHOD("skFontstylesetUnref", skFontstylesetUnref), DECLARE_NAPI_METHOD("skFontstylesetGetCount", skFontstylesetGetCount), DECLARE_NAPI_METHOD("skFontstylesetGetStyle", skFontstylesetGetStyle), DECLARE_NAPI_METHOD("skFontstylesetCreateTypeface", skFontstylesetCreateTypeface), DECLARE_NAPI_METHOD("skFontstylesetMatchStyle", skFontstylesetMatchStyle), DECLARE_NAPI_METHOD("skVerticesUnref", skVerticesUnref), DECLARE_NAPI_METHOD("skVerticesRef", skVerticesRef), DECLARE_NAPI_METHOD("skVerticesMakeCopy", skVerticesMakeCopy), DECLARE_NAPI_METHOD("skXmlstreamwriterNew", skXmlstreamwriterNew), DECLARE_NAPI_METHOD("skXmlstreamwriterDelete", skXmlstreamwriterDelete), }; 14 | status = napi_define_properties(env, exports, 768, desc); 15 | assert(status == napi_ok); 16 | return exports; 17 | } 18 | 19 | NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) 20 | --------------------------------------------------------------------------------