/* * Copyright 2018 Google LLC * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "include/android/SkAnimatedImage.h" #include "include/codec/SkAndroidCodec.h" #include "include/codec/SkCodec.h" #include "include/codec/SkEncodedImageFormat.h" #include "include/core/SkBBHFactory.h" #include "include/core/SkBlendMode.h" #include "include/core/SkBlender.h" #include "include/core/SkBlurTypes.h" #include "include/core/SkCanvas.h" #include "include/core/SkColor.h" #include "include/core/SkColorFilter.h" #include "include/core/SkColorSpace.h" #include "include/core/SkData.h" #include "include/core/SkImage.h" #include "include/core/SkImageFilter.h" #include "include/core/SkImageGenerator.h" #include "include/core/SkImageInfo.h" #include "include/core/SkM44.h" #include "include/core/SkMaskFilter.h" #include "include/core/SkPaint.h" #include "include/core/SkPath.h" #include "include/core/SkPathEffect.h" #include "include/core/SkPathMeasure.h" #include "include/core/SkPathUtils.h" #include "include/core/SkPicture.h" #include "include/core/SkPictureRecorder.h" #include "include/core/SkPoint3.h" #include "include/core/SkRRect.h" #include "include/core/SkSamplingOptions.h" #include "include/core/SkScalar.h" #include "include/core/SkSerialProcs.h" #include "include/core/SkShader.h" #include "include/core/SkStream.h" #include "include/core/SkString.h" #include "include/core/SkStrokeRec.h" #include "include/core/SkSurface.h" #include "include/core/SkTextBlob.h" #include "include/core/SkTypeface.h" #include "include/core/SkTypes.h" #include "include/core/SkVertices.h" #include "include/effects/Sk1DPathEffect.h" #include "include/effects/Sk2DPathEffect.h" #include "include/effects/SkCornerPathEffect.h" #include "include/effects/SkDashPathEffect.h" #include "include/effects/SkDiscretePathEffect.h" #include "include/effects/SkGradientShader.h" #include "include/effects/SkImageFilters.h" #include "include/effects/SkLumaColorFilter.h" #include "include/effects/SkPerlinNoiseShader.h" #include "include/effects/SkRuntimeEffect.h" #include "include/effects/SkTrimPathEffect.h" #include "include/encode/SkJpegEncoder.h" #include "include/encode/SkPngEncoder.h" #include "include/encode/SkWebpEncoder.h" #include "include/private/base/SkOnce.h" #include "include/utils/SkParsePath.h" #include "include/utils/SkShadowUtils.h" #include "src/base/SkFloatBits.h" #include "src/core/SkPathPriv.h" #include "src/core/SkResourceCache.h" #include "src/image/SkImage_Base.h" #include "src/sksl/SkSLCompiler.h" #include "modules/canvaskit/WasmCommon.h" #include #include #include #if defined(CK_ENABLE_WEBGL) || defined(CK_ENABLE_WEBGPU) #define ENABLE_GPU #endif #ifdef ENABLE_GPU #include "include/gpu/GpuTypes.h" #include "include/gpu/GrDirectContext.h" #include "include/gpu/ganesh/GrExternalTextureGenerator.h" #include "include/gpu/ganesh/SkImageGanesh.h" #include "include/gpu/ganesh/SkSurfaceGanesh.h" #include "src/gpu/ganesh/GrCaps.h" #endif // ENABLE_GPU #ifdef CK_ENABLE_WEBGL #include "include/gpu/GrBackendSurface.h" #include "include/gpu/GrTypes.h" #include "include/gpu/ganesh/gl/GrGLBackendSurface.h" #include "include/gpu/ganesh/gl/GrGLDirectContext.h" #include "include/gpu/ganesh/gl/GrGLMakeWebGLInterface.h" #include "include/gpu/gl/GrGLInterface.h" #include "include/gpu/gl/GrGLTypes.h" #include "src/gpu/RefCntedCallback.h" #include "src/gpu/ganesh/GrProxyProvider.h" #include "src/gpu/ganesh/GrRecordingContextPriv.h" #include "src/gpu/ganesh/gl/GrGLDefines.h" #include #endif // CK_ENABLE_WEBGL #ifdef CK_ENABLE_WEBGPU #include #include #include #endif // CK_ENABLE_WEBGPU #ifndef CK_NO_FONTS #include "include/core/SkFont.h" #include "include/core/SkFontMetrics.h" #include "include/core/SkFontMgr.h" #include "include/core/SkFontTypes.h" #include "src/ports/SkTypeface_FreeType.h" #ifdef CK_INCLUDE_PARAGRAPH #include "modules/skparagraph/include/Paragraph.h" #endif // CK_INCLUDE_PARAGRAPH #endif // CK_NO_FONTS #ifdef CK_INCLUDE_PATHOPS #include "include/pathops/SkPathOps.h" #endif #if defined(CK_INCLUDE_RUNTIME_EFFECT) #include "include/sksl/SkSLDebugTrace.h" #endif #ifndef CK_NO_FONTS #include "include/ports/SkFontMgr_data.h" #endif #if defined(CK_EMBED_FONT) struct SkEmbeddedResource { const uint8_t* data; size_t size; }; struct SkEmbeddedResourceHeader { const SkEmbeddedResource* entries; int count; }; extern "C" const SkEmbeddedResourceHeader SK_EMBEDDED_FONTS; #endif #if defined(GR_TEST_UTILS) #error "This define should not be set, as it brings in test-only things and bloats codesize." #endif #if defined(SK_CODEC_DECODES_BMP) #include "include/codec/SkBmpDecoder.h" #endif #if defined(SK_CODEC_DECODES_GIF) #include "include/codec/SkGifDecoder.h" #endif #if defined(SK_CODEC_DECODES_ICO) #include "include/codec/SkIcoDecoder.h" #endif #if defined(SK_CODEC_DECODES_JPEG) #include "include/codec/SkJpegDecoder.h" #endif #if defined(SK_CODEC_DECODES_PNG) #include "include/codec/SkPngDecoder.h" #endif #if defined(SK_CODEC_DECODES_WBMP) #include "include/codec/SkWbmpDecoder.h" #endif #if defined(SK_CODEC_DECODES_WEBP) #include "include/codec/SkWebpDecoder.h" #endif // We'd like clients to be able to compile in as many or few codecs as they want (e.g. codesize) std::unique_ptr DecodeImageData(sk_sp data) { if (data == nullptr) { return nullptr; } // These codecs are arbitrarily ordered in alphabetical order. #if defined(SK_CODEC_DECODES_BMP) if (SkBmpDecoder::IsBmp(data->data(), data->size())) { return SkBmpDecoder::Decode(data, nullptr); } #endif #if defined(SK_CODEC_DECODES_GIF) if (SkGifDecoder::IsGif(data->data(), data->size())) { return SkGifDecoder::Decode(data, nullptr); } #endif #if defined(SK_CODEC_DECODES_ICO) if (SkIcoDecoder::IsIco(data->data(), data->size())) { return SkIcoDecoder::Decode(data, nullptr); } #endif #if defined(SK_CODEC_DECODES_JPEG) if (SkJpegDecoder::IsJpeg(data->data(), data->size())) { return SkJpegDecoder::Decode(data, nullptr); } #endif #if defined(SK_CODEC_DECODES_PNG) if (SkPngDecoder::IsPng(data->data(), data->size())) { return SkPngDecoder::Decode(data, nullptr); } #endif #if defined(SK_CODEC_DECODES_WBMP) if (SkWbmpDecoder::IsWbmp(data->data(), data->size())) { return SkWbmpDecoder::Decode(data, nullptr); } #endif #if defined(SK_CODEC_DECODES_WEBP) if (SkWebpDecoder::IsWebp(data->data(), data->size())) { return SkWebpDecoder::Decode(data, nullptr); } #endif return nullptr; } struct OptionalMatrix : SkMatrix { OptionalMatrix(WASMPointerF32 mPtr) { if (mPtr) { const SkScalar* nineMatrixValues = reinterpret_cast(mPtr); this->set9(nineMatrixValues); } } }; SkColor4f ptrToSkColor4f(WASMPointerF32 cPtr) { float* fourFloats = reinterpret_cast(cPtr); SkColor4f color; memcpy(&color, fourFloats, 4 * sizeof(float)); return color; } SkRRect ptrToSkRRect(WASMPointerF32 fPtr) { // In order, these floats should be 4 floats for the rectangle // (left, top, right, bottom) and then 8 floats for the radii // (upper left, upper right, lower right, lower left). const SkScalar* twelveFloats = reinterpret_cast(fPtr); const SkRect rect = reinterpret_cast(twelveFloats)[0]; const SkVector* radiiValues = reinterpret_cast(twelveFloats + 4); SkRRect rr; rr.setRectRadii(rect, radiiValues); return rr; } // Surface creation structs and helpers struct SimpleImageInfo { int width; int height; SkColorType colorType; SkAlphaType alphaType; sk_sp colorSpace; }; SkImageInfo toSkImageInfo(const SimpleImageInfo& sii) { return SkImageInfo::Make(sii.width, sii.height, sii.colorType, sii.alphaType, sii.colorSpace ? sii.colorSpace : SkColorSpace::MakeSRGB()); } #ifdef CK_ENABLE_WEBGL // Set the pixel format based on the colortype. // These degrees of freedom are removed from canvaskit only to keep the interface simpler. struct ColorSettings { ColorSettings(sk_sp colorSpace) { if (colorSpace == nullptr || colorSpace->isSRGB()) { colorType = kRGBA_8888_SkColorType; pixFormat = GR_GL_RGBA8; } else { colorType = kRGBA_F16_SkColorType; pixFormat = GR_GL_RGBA16F; } } SkColorType colorType; GrGLenum pixFormat; }; sk_sp MakeGrContext() { // We assume that any calls we make to GL for the remainder of this function will go to the // desired WebGL Context. // setup interface. auto interface = GrGLInterfaces::MakeWebGL(); // setup context return GrDirectContexts::MakeGL(interface); } sk_sp MakeOnScreenGLSurface(sk_sp dContext, int width, int height, sk_sp colorSpace, int sampleCnt, int stencil) { // WebGL should already be clearing the color and stencil buffers, but do it again here to // ensure Skia receives them in the expected state. glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(0, 0, 0, 0); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); dContext->resetContext(kRenderTarget_GrGLBackendState | kMisc_GrGLBackendState); // The on-screen canvas is FBO 0. Wrap it in a Skia render target so Skia can render to it. GrGLFramebufferInfo info; info.fFBOID = 0; if (!colorSpace) { colorSpace = SkColorSpace::MakeSRGB(); } const auto colorSettings = ColorSettings(colorSpace); info.fFormat = colorSettings.pixFormat; auto target = GrBackendRenderTargets::MakeGL(width, height, sampleCnt, stencil, info); sk_sp surface(SkSurfaces::WrapBackendRenderTarget(dContext.get(), target, kBottomLeft_GrSurfaceOrigin, colorSettings.colorType, colorSpace, nullptr)); return surface; } sk_sp MakeOnScreenGLSurface(sk_sp dContext, int width, int height, sk_sp colorSpace) { GrGLint sampleCnt; glGetIntegerv(GL_SAMPLES, &sampleCnt); GrGLint stencil; glGetIntegerv(GL_STENCIL_BITS, &stencil); return MakeOnScreenGLSurface(dContext, width, height, colorSpace, sampleCnt, stencil); } sk_sp MakeRenderTarget(sk_sp dContext, int width, int height) { SkImageInfo info = SkImageInfo::MakeN32( width, height, SkAlphaType::kPremul_SkAlphaType, SkColorSpace::MakeSRGB()); sk_sp surface(SkSurfaces::RenderTarget(dContext.get(), skgpu::Budgeted::kYes, info, 0, kBottomLeft_GrSurfaceOrigin, nullptr, true)); return surface; } sk_sp MakeRenderTarget(sk_sp dContext, SimpleImageInfo sii) { sk_sp surface(SkSurfaces::RenderTarget(dContext.get(), skgpu::Budgeted::kYes, toSkImageInfo(sii), 0, kBottomLeft_GrSurfaceOrigin, nullptr, true)); return surface; } #endif // CK_ENABLE_WEBGL #ifdef CK_ENABLE_WEBGPU sk_sp MakeGrContext() { GrContextOptions options; wgpu::Device device = wgpu::Device::Acquire(emscripten_webgpu_get_device()); return GrDirectContext::MakeDawn(device, options); } sk_sp MakeGPUTextureSurface(sk_sp dContext, uint32_t textureHandle, uint32_t textureFormat, int width, int height, sk_sp colorSpace) { if (!colorSpace) { colorSpace = SkColorSpace::MakeSRGB(); } wgpu::TextureFormat format = static_cast(textureFormat); wgpu::Texture texture(emscripten_webgpu_import_texture(textureHandle)); emscripten_webgpu_release_js_handle(textureHandle); // GrDawnRenderTargetInfo currently only supports a 1-mip TextureView. constexpr uint32_t mipLevelCount = 1; constexpr uint32_t sampleCount = 1; GrDawnTextureInfo info; info.fTexture = texture; info.fFormat = format; info.fLevelCount = mipLevelCount; GrBackendTexture target(width, height, info); return SkSurfaces::WrapBackendTexture( dContext.get(), target, kTopLeft_GrSurfaceOrigin, sampleCount, colorSpace->isSRGB() ? kRGBA_8888_SkColorType : kRGBA_F16_SkColorType, colorSpace, nullptr); } bool ReplaceBackendTexture(SkSurface& surface, uint32_t textureHandle, uint32_t textureFormat, int width, int height) { wgpu::TextureFormat format = static_cast(textureFormat); wgpu::Texture texture(emscripten_webgpu_import_texture(textureHandle)); emscripten_webgpu_release_js_handle(textureHandle); GrDawnTextureInfo info; info.fTexture = texture; info.fFormat = format; info.fLevelCount = 1; // Use kDiscard_ContentChangeMode to discard the contents of the old backing texture. This not // only avoids an unnecessary blit, we also don't support copying the contents of a swapchain // texture due to the default GPUCanvasConfiguration usage bits we used when configuring the // GPUCanvasContext in JS. // // The default usage bits only contain GPUTextureUsage.RENDER_ATTACHMENT. To support a copy we // would need to also set GPUTextureUsage.TEXTURE_BINDING (to sample it in a shader) or // GPUTextureUsage.COPY_SRC (for a copy command). // // See https://www.w3.org/TR/webgpu/#namespacedef-gputextureusage and // https://www.w3.org/TR/webgpu/#dictdef-gpucanvasconfiguration. GrBackendTexture target(width, height, info); return surface.replaceBackendTexture(target, kTopLeft_GrSurfaceOrigin, SkSurface::kDiscard_ContentChangeMode); } #endif // CK_ENABLE_WEBGPU //======================================================================================== // Path things //======================================================================================== // All these Apply* methods are simple wrappers to avoid returning an object. // The default WASM bindings produce code that will leak if a return value // isn't assigned to a JS variable and has delete() called on it. // These Apply methods, combined with the smarter binding code allow for chainable // commands that don't leak if the return value is ignored (i.e. when used intuitively). void ApplyAddPath(SkPath& orig, const SkPath& newPath, SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2, bool extendPath) { SkMatrix m = SkMatrix::MakeAll(scaleX, skewX , transX, skewY , scaleY, transY, pers0 , pers1 , pers2); orig.addPath(newPath, m, extendPath ? SkPath::kExtend_AddPathMode : SkPath::kAppend_AddPathMode); } void ApplyArcToTangent(SkPath& p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar radius) { p.arcTo(x1, y1, x2, y2, radius); } void ApplyArcToArcSize(SkPath& orig, SkScalar rx, SkScalar ry, SkScalar xAxisRotate, bool useSmallArc, bool ccw, SkScalar x, SkScalar y) { auto arcSize = useSmallArc ? SkPath::ArcSize::kSmall_ArcSize : SkPath::ArcSize::kLarge_ArcSize; auto sweep = ccw ? SkPathDirection::kCCW : SkPathDirection::kCW; orig.arcTo(rx, ry, xAxisRotate, arcSize, sweep, x, y); } void ApplyRArcToArcSize(SkPath& orig, SkScalar rx, SkScalar ry, SkScalar xAxisRotate, bool useSmallArc, bool ccw, SkScalar dx, SkScalar dy) { auto arcSize = useSmallArc ? SkPath::ArcSize::kSmall_ArcSize : SkPath::ArcSize::kLarge_ArcSize; auto sweep = ccw ? SkPathDirection::kCCW : SkPathDirection::kCW; orig.rArcTo(rx, ry, xAxisRotate, arcSize, sweep, dx, dy); } void ApplyClose(SkPath& p) { p.close(); } void ApplyConicTo(SkPath& p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w) { p.conicTo(x1, y1, x2, y2, w); } void ApplyRConicTo(SkPath& p, SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, SkScalar w) { p.rConicTo(dx1, dy1, dx2, dy2, w); } void ApplyCubicTo(SkPath& p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3) { p.cubicTo(x1, y1, x2, y2, x3, y3); } void ApplyRCubicTo(SkPath& p, SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, SkScalar dx3, SkScalar dy3) { p.rCubicTo(dx1, dy1, dx2, dy2, dx3, dy3); } void ApplyLineTo(SkPath& p, SkScalar x, SkScalar y) { p.lineTo(x, y); } void ApplyRLineTo(SkPath& p, SkScalar dx, SkScalar dy) { p.rLineTo(dx, dy); } void ApplyMoveTo(SkPath& p, SkScalar x, SkScalar y) { p.moveTo(x, y); } void ApplyRMoveTo(SkPath& p, SkScalar dx, SkScalar dy) { p.rMoveTo(dx, dy); } void ApplyReset(SkPath& p) { p.reset(); } void ApplyRewind(SkPath& p) { p.rewind(); } void ApplyQuadTo(SkPath& p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) { p.quadTo(x1, y1, x2, y2); } void ApplyRQuadTo(SkPath& p, SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2) { p.rQuadTo(dx1, dy1, dx2, dy2); } void ApplyTransform(SkPath& orig, SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2) { SkMatrix m = SkMatrix::MakeAll(scaleX, skewX , transX, skewY , scaleY, transY, pers0 , pers1 , pers2); orig.transform(m); } #ifdef CK_INCLUDE_PATHOPS bool ApplySimplify(SkPath& path) { return Simplify(path, &path); } bool ApplyPathOp(SkPath& pathOne, const SkPath& pathTwo, SkPathOp op) { return Op(pathOne, pathTwo, op, &pathOne); } SkPathOrNull MakePathFromOp(const SkPath& pathOne, const SkPath& pathTwo, SkPathOp op) { SkPath out; if (Op(pathOne, pathTwo, op, &out)) { return emscripten::val(out); } return emscripten::val::null(); } SkPathOrNull MakeAsWinding(const SkPath& self) { SkPath out; if (AsWinding(self, &out)) { return emscripten::val(out); } return emscripten::val::null(); } #endif JSString ToSVGString(const SkPath& path) { return emscripten::val(SkParsePath::ToSVGString(path).c_str()); } SkPathOrNull MakePathFromSVGString(std::string str) { SkPath path; if (SkParsePath::FromSVGString(str.c_str(), &path)) { return emscripten::val(path); } return emscripten::val::null(); } bool CanInterpolate(const SkPath& path1, const SkPath& path2) { return path1.isInterpolatable(path2); } SkPathOrNull MakePathFromInterpolation(const SkPath& path1, const SkPath& path2, SkScalar weight) { SkPath out; bool succeed = path1.interpolate(path2, weight, &out); if (succeed) { return emscripten::val(out); } return emscripten::val::null(); } SkPath CopyPath(const SkPath& a) { SkPath copy(a); return copy; } bool Equals(const SkPath& a, const SkPath& b) { return a == b; } // ================================================================================= // Creating/Exporting Paths with cmd arrays // ================================================================================= static const int MOVE = 0; static const int LINE = 1; static const int QUAD = 2; static const int CONIC = 3; static const int CUBIC = 4; static const int CLOSE = 5; Float32Array ToCmds(const SkPath& path) { std::vector cmds; for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) { switch (verb) { case SkPathVerb::kMove: cmds.insert(cmds.end(), {MOVE, pts[0].x(), pts[0].y()}); break; case SkPathVerb::kLine: cmds.insert(cmds.end(), {LINE, pts[1].x(), pts[1].y()}); break; case SkPathVerb::kQuad: cmds.insert(cmds.end(), {QUAD, pts[1].x(), pts[1].y(), pts[2].x(), pts[2].y()}); break; case SkPathVerb::kConic: cmds.insert(cmds.end(), {CONIC, pts[1].x(), pts[1].y(), pts[2].x(), pts[2].y(), *w}); break; case SkPathVerb::kCubic: cmds.insert(cmds.end(), {CUBIC, pts[1].x(), pts[1].y(), pts[2].x(), pts[2].y(), pts[3].x(), pts[3].y()}); break; case SkPathVerb::kClose: cmds.push_back(CLOSE); break; } } return MakeTypedArray(cmds.size(), (const float*)cmds.data()); } SkPathOrNull MakePathFromCmds(WASMPointerF32 cptr, int numCmds) { const auto* cmds = reinterpret_cast(cptr); SkPath path; float x1, y1, x2, y2, x3, y3; // if there are not enough arguments, bail with the path we've constructed so far. #define CHECK_NUM_ARGS(n) \ if ((i + n) > numCmds) { \ SkDebugf("Not enough args to match the verbs. Saw %d commands\n", numCmds); \ return emscripten::val::null(); \ } for(int i = 0; i < numCmds;){ switch (sk_float_floor2int(cmds[i++])) { case MOVE: CHECK_NUM_ARGS(2) x1 = cmds[i++]; y1 = cmds[i++]; path.moveTo(x1, y1); break; case LINE: CHECK_NUM_ARGS(2) x1 = cmds[i++]; y1 = cmds[i++]; path.lineTo(x1, y1); break; case QUAD: CHECK_NUM_ARGS(4) x1 = cmds[i++]; y1 = cmds[i++]; x2 = cmds[i++]; y2 = cmds[i++]; path.quadTo(x1, y1, x2, y2); break; case CONIC: CHECK_NUM_ARGS(5) x1 = cmds[i++]; y1 = cmds[i++]; x2 = cmds[i++]; y2 = cmds[i++]; x3 = cmds[i++]; // weight path.conicTo(x1, y1, x2, y2, x3); break; case CUBIC: CHECK_NUM_ARGS(6) x1 = cmds[i++]; y1 = cmds[i++]; x2 = cmds[i++]; y2 = cmds[i++]; x3 = cmds[i++]; y3 = cmds[i++]; path.cubicTo(x1, y1, x2, y2, x3, y3); break; case CLOSE: path.close(); break; default: SkDebugf(" path: UNKNOWN command %f, aborting dump...\n", cmds[i-1]); return emscripten::val::null(); } } #undef CHECK_NUM_ARGS return emscripten::val(path); } void PathAddVerbsPointsWeights(SkPath& path, WASMPointerU8 verbsPtr, int numVerbs, WASMPointerF32 ptsPtr, int numPts, WASMPointerF32 wtsPtr, int numWts) { const uint8_t* verbs = reinterpret_cast(verbsPtr); const float* pts = reinterpret_cast(ptsPtr); const float* weights = reinterpret_cast(wtsPtr); #define CHECK_NUM_POINTS(n) \ if ((ptIdx + n) > numPts) { \ SkDebugf("Not enough points to match the verbs. Saw %d points\n", numPts); \ return; \ } #define CHECK_NUM_WEIGHTS(n) \ if ((wtIdx + n) > numWts) { \ SkDebugf("Not enough weights to match the verbs. Saw %d weights\n", numWts); \ return; \ } path.incReserve(numPts); int ptIdx = 0; int wtIdx = 0; for (int v = 0; v < numVerbs; ++v) { switch (verbs[v]) { case MOVE: CHECK_NUM_POINTS(2) path.moveTo(pts[ptIdx], pts[ptIdx+1]); ptIdx += 2; break; case LINE: CHECK_NUM_POINTS(2) path.lineTo(pts[ptIdx], pts[ptIdx+1]); ptIdx += 2; break; case QUAD: CHECK_NUM_POINTS(4) path.quadTo(pts[ptIdx], pts[ptIdx+1], pts[ptIdx+2], pts[ptIdx+3]); ptIdx += 4; break; case CONIC: CHECK_NUM_POINTS(4) CHECK_NUM_WEIGHTS(1) path.conicTo(pts[ptIdx], pts[ptIdx+1], pts[ptIdx+2], pts[ptIdx+3], weights[wtIdx]); ptIdx += 4; wtIdx++; break; case CUBIC: CHECK_NUM_POINTS(6) path.cubicTo(pts[ptIdx ], pts[ptIdx+1], pts[ptIdx+2], pts[ptIdx+3], pts[ptIdx+4], pts[ptIdx+5]); ptIdx += 6; break; case CLOSE: path.close(); break; } } #undef CHECK_NUM_POINTS #undef CHECK_NUM_WEIGHTS } SkPath MakePathFromVerbsPointsWeights(WASMPointerU8 verbsPtr, int numVerbs, WASMPointerF32 ptsPtr, int numPts, WASMPointerF32 wtsPtr, int numWts) { SkPath path; PathAddVerbsPointsWeights(path, verbsPtr, numVerbs, ptsPtr, numPts, wtsPtr, numWts); return path; } //======================================================================================== // Path Effects //======================================================================================== bool ApplyDash(SkPath& path, SkScalar on, SkScalar off, SkScalar phase) { SkScalar intervals[] = { on, off }; auto pe = SkDashPathEffect::Make(intervals, 2, phase); if (!pe) { SkDebugf("Invalid args to dash()\n"); return false; } SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle); if (pe->filterPath(&path, path, &rec, nullptr)) { return true; } SkDebugf("Could not make dashed path\n"); return false; } bool ApplyTrim(SkPath& path, SkScalar startT, SkScalar stopT, bool isComplement) { auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted : SkTrimPathEffect::Mode::kNormal; auto pe = SkTrimPathEffect::Make(startT, stopT, mode); if (!pe) { SkDebugf("Invalid args to trim(): startT and stopT must be in [0,1]\n"); return false; } SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle); if (pe->filterPath(&path, path, &rec, nullptr)) { return true; } SkDebugf("Could not trim path\n"); return false; } struct StrokeOpts { // Default values are set in interface.js which allows clients // to set any number of them. Otherwise, the binding code complains if // any are omitted. SkScalar width; SkScalar miter_limit; SkPaint::Join join; SkPaint::Cap cap; float precision; }; bool ApplyStroke(SkPath& path, StrokeOpts opts) { SkPaint p; p.setStyle(SkPaint::kStroke_Style); p.setStrokeCap(opts.cap); p.setStrokeJoin(opts.join); p.setStrokeWidth(opts.width); p.setStrokeMiter(opts.miter_limit); return skpathutils::FillPathWithPaint(path, p, &path, nullptr, opts.precision); } // This function is private, we call it in interface.js void computeTonalColors(WASMPointerF32 cPtrAmbi, WASMPointerF32 cPtrSpot) { // private methods accepting colors take pointers to floats already copied into wasm memory. float* ambiFloats = reinterpret_cast(cPtrAmbi); float* spotFloats = reinterpret_cast(cPtrSpot); SkColor4f ambiColor = { ambiFloats[0], ambiFloats[1], ambiFloats[2], ambiFloats[3]}; SkColor4f spotColor = { spotFloats[0], spotFloats[1], spotFloats[2], spotFloats[3]}; // This function takes SkColor SkColor resultAmbi, resultSpot; SkShadowUtils::ComputeTonalColors( ambiColor.toSkColor(), spotColor.toSkColor(), &resultAmbi, &resultSpot); // Convert back to color4f const SkColor4f ambi4f = SkColor4f::FromColor(resultAmbi); const SkColor4f spot4f = SkColor4f::FromColor(resultSpot); // Re-use the caller's allocated memory to hold the result. memcpy(ambiFloats, ambi4f.vec(), 4 * sizeof(SkScalar)); memcpy(spotFloats, spot4f.vec(), 4 * sizeof(SkScalar)); } #ifdef CK_INCLUDE_RUNTIME_EFFECT struct RuntimeEffectUniform { int columns; int rows; int slot; // the index into the uniforms array that this uniform begins. bool isInteger; }; RuntimeEffectUniform fromUniform(const SkRuntimeEffect::Uniform& u) { RuntimeEffectUniform su; su.rows = u.count; // arrayLength su.columns = 1; su.isInteger = false; using Type = SkRuntimeEffect::Uniform::Type; switch (u.type) { case Type::kFloat: break; case Type::kFloat2: su.columns = 2; break; case Type::kFloat3: su.columns = 3; break; case Type::kFloat4: su.columns = 4; break; case Type::kFloat2x2: su.columns = 2; su.rows *= 2; break; case Type::kFloat3x3: su.columns = 3; su.rows *= 3; break; case Type::kFloat4x4: su.columns = 4; su.rows *= 4; break; case Type::kInt: su.isInteger = true; break; case Type::kInt2: su.columns = 2; su.isInteger = true; break; case Type::kInt3: su.columns = 3; su.isInteger = true; break; case Type::kInt4: su.columns = 4; su.isInteger = true; break; } su.slot = u.offset / sizeof(float); return su; } void castUniforms(void* data, size_t dataLen, const SkRuntimeEffect& effect) { if (dataLen != effect.uniformSize()) { // Incorrect number of uniforms. Our code below could read/write off the end of the buffer. // However, shader creation is going to fail anyway, so just do nothing. return; } float* fltData = reinterpret_cast(data); for (const auto& u : effect.uniforms()) { RuntimeEffectUniform reu = fromUniform(u); if (reu.isInteger) { // The SkSL is expecting integers in the uniform data for (int i = 0; i < reu.columns * reu.rows; ++i) { int numAsInt = static_cast(fltData[reu.slot + i]); fltData[reu.slot + i] = SkBits2Float(numAsInt); } } } } #endif sk_sp alwaysSaveTypefaceBytes(SkTypeface* face, void*) { return face->serialize(SkTypeface::SerializeBehavior::kDoIncludeData); } // These objects have private destructors / delete methods - I don't think // we need to do anything other than tell emscripten to do nothing. namespace emscripten { namespace internal { template void raw_destructor(ClassType*); template<> void raw_destructor(SkContourMeasure* ptr) { } template<> void raw_destructor(SkVertices* ptr) { } #ifndef CK_NO_FONTS template<> void raw_destructor(SkTextBlob* ptr) { } template<> void raw_destructor(SkTypeface* ptr) { } #endif } } // toBytes returns a Uint8Array that has a copy of the data in the given SkData. Uint8Array toBytes(sk_sp data) { // By making the copy using the JS transliteration, we don't risk the SkData object being // cleaned up before we make the copy. return emscripten::val( // https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-views typed_memory_view(data->size(), data->bytes()) ).call("slice"); // slice with no args makes a copy of the memory view. } #ifdef CK_ENABLE_WEBGL // We need to call into the JS side of things to free webGL contexts. This object will be called // with _setTextureCleanup after CanvasKit loads. The object will have one attribute, // a function called deleteTexture that takes two ints. JSObject textureCleanup = emscripten::val::null(); struct TextureReleaseContext { // This refers to which webgl context, i.e. which surface, owns the texture. We need this // to route the deleteTexture to the right context. uint32_t webglHandle; // This refers to the index of the texture in the complete list of textures. uint32_t texHandle; }; void deleteJSTexture(SkImages::ReleaseContext rc) { auto ctx = reinterpret_cast(rc); textureCleanup.call("deleteTexture", ctx->webglHandle, ctx->texHandle); delete ctx; } class ExternalWebGLTexture : public GrExternalTexture { public: ExternalWebGLTexture(GrBackendTexture backendTexture, uint32_t textureHandle, EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context) : fBackendTexture(backendTexture), fWebglHandle(context), fTextureHandle(textureHandle) {} GrBackendTexture getBackendTexture() override { return fBackendTexture; } void dispose() override { textureCleanup.call("deleteTexture", fWebglHandle, fTextureHandle); } private: GrBackendTexture fBackendTexture; // This refers to which webgl context, i.e. which surface, owns the texture. We need this // to route the deleteTexture to the right context. uint32_t fWebglHandle; // This refers to the index of the texture in the complete list of textures. uint32_t fTextureHandle; }; class WebGLTextureImageGenerator : public GrExternalTextureGenerator { public: WebGLTextureImageGenerator(SkImageInfo ii, JSObject callbackObj): GrExternalTextureGenerator(ii), fCallback(callbackObj) {} ~WebGLTextureImageGenerator() override { // This cleans up the associated TextureSource that is used to make the texture // (i.e. "makeTexture" below). We expect this destructor to be called when the // SkImage that this Generator belongs to is destroyed. fCallback.call("freeSrc"); } std::unique_ptr generateExternalTexture(GrRecordingContext* ctx, skgpu::Mipmapped) override { GrGLTextureInfo glInfo; // This callback is defined in webgl.js glInfo.fID = fCallback.call("makeTexture"); // The format and target should match how we make the texture on the JS side // See the implementation of the makeTexture function. glInfo.fFormat = GR_GL_RGBA8; glInfo.fTarget = GR_GL_TEXTURE_2D; // These textures are unlikely to actually have mipmaps generated (we might even be on // WebGL 1, where Skia doesn't support mipmapping at all). Therefore, we ignore any request // for mipmapping here. See: b/338095525 auto backendTexture = GrBackendTextures::MakeGL( fInfo.width(), fInfo.height(), skgpu::Mipmapped::kNo, glInfo); // In order to bind the image source to the texture, makeTexture has changed which // texture is "in focus" for the WebGL context. GrAsDirectContext(ctx)->resetContext(kTextureBinding_GrGLBackendState); return std::make_unique( backendTexture, glInfo.fID, emscripten_webgl_get_current_context()); } private: JSObject fCallback; }; // callbackObj has two functions in it, one to create a texture "makeTexture" and one to clean up // the underlying texture source "freeSrc". This way, we can create WebGL textures for each // surface/WebGLContext that the image is used on (we cannot share WebGLTextures across contexts). sk_sp MakeImageFromGenerator(SimpleImageInfo ii, JSObject callbackObj) { auto gen = std::make_unique(toSkImageInfo(ii), callbackObj); return SkImages::DeferredFromTextureGenerator(std::move(gen)); } #endif // CK_ENABLE_WEBGL static Uint8Array encodeImage(GrDirectContext* dContext, sk_sp img, SkEncodedImageFormat fmt, int quality) { sk_sp data = nullptr; if (fmt == SkEncodedImageFormat::kJPEG) { SkJpegEncoder::Options opts; opts.fQuality = quality; data = SkJpegEncoder::Encode(dContext, img.get(), opts); } else if (fmt == SkEncodedImageFormat::kPNG) { data = SkPngEncoder::Encode(dContext, img.get(), {}); } else { SkWebpEncoder::Options opts; if (quality >= 100) { opts.fCompression = SkWebpEncoder::Compression::kLossless; opts.fQuality = 75; // This is effort to compress } else { opts.fCompression = SkWebpEncoder::Compression::kLossy; opts.fQuality = quality; } data = SkWebpEncoder::Encode(dContext, img.get(), opts); } if (!data) { return emscripten::val::null(); } return toBytes(data); } EMSCRIPTEN_BINDINGS(Skia) { #ifdef ENABLE_GPU constant("gpu", true); function("_MakeGrContext", &MakeGrContext); #endif // ENABLE_GPU #ifdef CK_ENABLE_WEBGL constant("webgl", true); function("_MakeOnScreenGLSurface", select_overload(sk_sp, int, int, sk_sp)>(&MakeOnScreenGLSurface)); function("_MakeOnScreenGLSurface", select_overload(sk_sp, int, int, sk_sp, int, int)>(&MakeOnScreenGLSurface)); function("_MakeRenderTargetWH", select_overload(sk_sp, int, int)>(&MakeRenderTarget)); function("_MakeRenderTargetII", select_overload(sk_sp, SimpleImageInfo)>(&MakeRenderTarget)); #endif // CK_ENABLE_WEBGL #ifdef CK_ENABLE_WEBGPU constant("webgpu", true); function("_MakeGPUTextureSurface", &MakeGPUTextureSurface); #endif // CK_ENABLE_WEBGPU function("getDecodeCacheLimitBytes", &SkResourceCache::GetTotalByteLimit); function("setDecodeCacheLimitBytes", &SkResourceCache::SetTotalByteLimit); function("getDecodeCacheUsedBytes" , &SkResourceCache::GetTotalBytesUsed); function("_computeTonalColors", &computeTonalColors); function("_decodeAnimatedImage", optional_override([](WASMPointerU8 iptr, size_t length)->sk_sp { uint8_t* imgData = reinterpret_cast(iptr); auto bytes = SkData::MakeFromMalloc(imgData, length); auto codec = DecodeImageData(bytes); if (codec == nullptr) { return nullptr; } auto aCodec = SkAndroidCodec::MakeFromCodec(std::move(codec)); if (aCodec == nullptr) { return nullptr; } return SkAnimatedImage::Make(std::move(aCodec)); }), allow_raw_pointers()); function("_decodeImage", optional_override([](WASMPointerU8 iptr, size_t length)->sk_sp { uint8_t* imgData = reinterpret_cast(iptr); auto bytes = SkData::MakeFromMalloc(imgData, length); auto codec = DecodeImageData(bytes); if (codec == nullptr) { return nullptr; } return std::get<0>(codec->getImage()); }), allow_raw_pointers()); // These won't be called directly, there are corresponding JS helpers to deal with arrays. function("_MakeImage", optional_override([](SimpleImageInfo ii, WASMPointerU8 pPtr, int plen, size_t rowBytes)->sk_sp { uint8_t* pixels = reinterpret_cast(pPtr); SkImageInfo info = toSkImageInfo(ii); sk_sp pixelData = SkData::MakeFromMalloc(pixels, plen); return SkImages::RasterFromData(info, pixelData, rowBytes); }), allow_raw_pointers()); function("_getShadowLocalBounds", optional_override([]( WASMPointerF32 ctmPtr, const SkPath& path, WASMPointerF32 zPlaneParamPtr, WASMPointerF32 lightPosPtr, SkScalar lightRadius, uint32_t flags, WASMPointerF32 outPtr) -> bool { SkMatrix ctm; const SkScalar* nineMatrixValues = reinterpret_cast(ctmPtr); ctm.set9(nineMatrixValues); const SkVector3* zPlaneParams = reinterpret_cast(zPlaneParamPtr); const SkVector3* lightPos = reinterpret_cast(lightPosPtr); SkRect* outputBounds = reinterpret_cast(outPtr); return SkShadowUtils::GetLocalBounds(ctm, path, *zPlaneParams, *lightPos, lightRadius, flags, outputBounds); })); #ifdef CK_SERIALIZE_SKP function("_MakePicture", optional_override([](WASMPointerU8 dPtr, size_t bytes)->sk_sp { uint8_t* d = reinterpret_cast(dPtr); sk_sp data = SkData::MakeFromMalloc(d, bytes); #ifndef CK_NO_FONTS // Be sure we can process the data stored when serializing the SkPicture. static SkOnce once; once([] { SkTypeface::Register(SkTypeface_FreeType::FactoryId, SkTypeface_FreeType::MakeFromStream ); }); #endif SkDeserialProcs dp; dp.fImageDataProc = [](sk_sp bytes, std::optional at, void* ctx) -> sk_sp { auto codec = DecodeImageData(bytes); if (codec == nullptr) { return nullptr; } SkImageInfo info = codec->getInfo(); if (at.has_value()) { info = info.makeAlphaType(*at); } else if (kUnpremul_SkAlphaType == info.alphaType()) { // Otherwise, prefer premul over unpremul (this produces better filtering in general) info = info.makeAlphaType(kPremul_SkAlphaType); } return std::get<0>(codec->getImage(info)); }; return SkPicture::MakeFromData(data.get(), nullptr); }), allow_raw_pointers()); #endif #ifdef ENABLE_GPU class_("GrDirectContext") .smart_ptr>("sk_sp") .function("_getResourceCacheLimitBytes", optional_override([](GrDirectContext& self)->size_t { int maxResources = 0;// ignored size_t currMax = 0; self.getResourceCacheLimits(&maxResources, &currMax); return currMax; })) .function("_getResourceCacheUsageBytes", optional_override([](GrDirectContext& self)->size_t { int usedResources = 0;// ignored size_t currUsage = 0; self.getResourceCacheUsage(&usedResources, &currUsage); return currUsage; })) .function("_releaseResourcesAndAbandonContext", &GrDirectContext::releaseResourcesAndAbandonContext) .function("_setResourceCacheLimitBytes", optional_override([](GrDirectContext& self, size_t maxResourceBytes)->void { int maxResources = 0; size_t currMax = 0; // ignored self.getResourceCacheLimits(&maxResources, &currMax); self.setResourceCacheLimits(maxResources, maxResourceBytes); })); #endif // ENABLE_GPU #ifdef CK_ENABLE_WEBGL // This allows us to give the C++ code a JS callback to delete textures that // have been passed in via makeImageFromTexture and makeImageFromTextureSource. function("_setTextureCleanup", optional_override([](JSObject callbackObj)->void { textureCleanup = callbackObj; })); #endif class_("AnimatedImage") .smart_ptr>("sk_sp") .function("currentFrameDuration", &SkAnimatedImage::currentFrameDuration) .function("decodeNextFrame", &SkAnimatedImage::decodeNextFrame) .function("getFrameCount", &SkAnimatedImage::getFrameCount) .function("getRepetitionCount", &SkAnimatedImage::getRepetitionCount) .function("height", optional_override([](SkAnimatedImage& self)->int32_t { // getBounds returns an SkRect, but internally, the width and height are ints. return SkScalarFloorToInt(self.getBounds().height()); })) .function("makeImageAtCurrentFrame", &SkAnimatedImage::getCurrentFrame) .function("reset", &SkAnimatedImage::reset) .function("width", optional_override([](SkAnimatedImage& self)->int32_t { return SkScalarFloorToInt(self.getBounds().width()); })); class_("Blender") .smart_ptr>("sk_sp") .class_function("Mode", &SkBlender::Mode); class_("Canvas") .constructor<>() .constructor() .function("_clear", optional_override([](SkCanvas& self, WASMPointerF32 cPtr) { self.clear(ptrToSkColor4f(cPtr)); })) .function("clipPath", select_overload(&SkCanvas::clipPath)) .function("_clipRRect", optional_override([](SkCanvas& self, WASMPointerF32 fPtr, SkClipOp op, bool doAntiAlias) { self.clipRRect(ptrToSkRRect(fPtr), op, doAntiAlias); })) .function("_clipRect", optional_override([](SkCanvas& self, WASMPointerF32 fPtr, SkClipOp op, bool doAntiAlias) { const SkRect* rect = reinterpret_cast(fPtr); self.clipRect(*rect, op, doAntiAlias); })) .function("_concat", optional_override([](SkCanvas& self, WASMPointerF32 mPtr) { //TODO(skbug.com/10108): make the JS side be column major. const SkScalar* sixteenMatrixValues = reinterpret_cast(mPtr); SkM44 m = SkM44::RowMajor(sixteenMatrixValues); self.concat(m); })) .function("_drawArc", optional_override([](SkCanvas& self, WASMPointerF32 fPtr, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint) { const SkRect* oval = reinterpret_cast(fPtr); self.drawArc(*oval, startAngle, sweepAngle, useCenter, paint); })) .function("_drawAtlasOptions", optional_override([](SkCanvas& self, const sk_sp& atlas, WASMPointerF32 xptr, WASMPointerF32 rptr, WASMPointerU32 cptr, int count, SkBlendMode mode, SkFilterMode filter, SkMipmapMode mipmap, const SkPaint* paint)->void { const SkRSXform* dstXforms = reinterpret_cast(xptr); const SkRect* srcRects = reinterpret_cast(rptr); const SkColor* colors = nullptr; if (cptr) { colors = reinterpret_cast(cptr); } SkSamplingOptions sampling(filter, mipmap); self.drawAtlas(atlas.get(), dstXforms, srcRects, colors, count, mode, sampling, nullptr, paint); }), allow_raw_pointers()) .function("_drawAtlasCubic", optional_override([](SkCanvas& self, const sk_sp& atlas, WASMPointerF32 xptr, WASMPointerF32 rptr, WASMPointerU32 cptr, int count, SkBlendMode mode, float B, float C, const SkPaint* paint)->void { const SkRSXform* dstXforms = reinterpret_cast(xptr); const SkRect* srcRects = reinterpret_cast(rptr); const SkColor* colors = nullptr; if (cptr) { colors = reinterpret_cast(cptr); } SkSamplingOptions sampling({B, C}); self.drawAtlas(atlas.get(), dstXforms, srcRects, colors, count, mode, sampling, nullptr, paint); }), allow_raw_pointers()) .function("_drawCircle", select_overload(&SkCanvas::drawCircle)) .function("_drawColor", optional_override([](SkCanvas& self, WASMPointerF32 cPtr) { self.drawColor(ptrToSkColor4f(cPtr)); })) .function("_drawColor", optional_override([](SkCanvas& self, WASMPointerF32 cPtr, SkBlendMode mode) { self.drawColor(ptrToSkColor4f(cPtr), mode); })) .function("_drawColorInt", optional_override([](SkCanvas& self, SkColor color, SkBlendMode mode) { self.drawColor(color, mode); })) .function("_drawDRRect", optional_override([](SkCanvas& self, WASMPointerF32 outerPtr, WASMPointerF32 innerPtr, const SkPaint& paint) { self.drawDRRect(ptrToSkRRect(outerPtr), ptrToSkRRect(innerPtr), paint); })) .function("_drawGlyphs", optional_override([](SkCanvas& self, int count, WASMPointerU16 glyphs, WASMPointerF32 positions, float x, float y, const SkFont& font, const SkPaint& paint)->void { self.drawGlyphs(count, reinterpret_cast(glyphs), reinterpret_cast(positions), {x, y}, font, paint); })) // TODO: deprecate this version, and require sampling .function("_drawImage", optional_override([](SkCanvas& self, const sk_sp& image, SkScalar x, SkScalar y, const SkPaint* paint) { self.drawImage(image.get(), x, y, SkSamplingOptions(), paint); }), allow_raw_pointers()) .function("_drawImageCubic", optional_override([](SkCanvas& self, const sk_sp& img, SkScalar left, SkScalar top, float B, float C, // See SkSamplingOptions.h for docs. const SkPaint* paint)->void { self.drawImage(img.get(), left, top, SkSamplingOptions({B, C}), paint); }), allow_raw_pointers()) .function("_drawImageOptions", optional_override([](SkCanvas& self, const sk_sp& img, SkScalar left, SkScalar top, SkFilterMode filter, SkMipmapMode mipmap, const SkPaint* paint)->void { self.drawImage(img.get(), left, top, {filter, mipmap}, paint); }), allow_raw_pointers()) .function("_drawImageNine", optional_override([](SkCanvas& self, const sk_sp& image, WASMPointerU32 centerPtr, WASMPointerF32 dstPtr, SkFilterMode filter, const SkPaint* paint)->void { const SkIRect* center = reinterpret_cast(centerPtr); const SkRect* dst = reinterpret_cast(dstPtr); self.drawImageNine(image.get(), *center, *dst, filter, paint); }), allow_raw_pointers()) // TODO: deprecate this version, and require sampling .function("_drawImageRect", optional_override([](SkCanvas& self, const sk_sp& image, WASMPointerF32 srcPtr, WASMPointerF32 dstPtr, const SkPaint* paint, bool fastSample)->void { const SkRect* src = reinterpret_cast(srcPtr); const SkRect* dst = reinterpret_cast(dstPtr); self.drawImageRect(image, *src, *dst, SkSamplingOptions(), paint, fastSample ? SkCanvas::kFast_SrcRectConstraint: SkCanvas::kStrict_SrcRectConstraint); }), allow_raw_pointers()) .function("_drawImageRectCubic", optional_override([](SkCanvas& self, const sk_sp& image, WASMPointerF32 srcPtr, WASMPointerF32 dstPtr, float B, float C, // See SkSamplingOptions.h for docs. const SkPaint* paint)->void { const SkRect* src = reinterpret_cast(srcPtr); const SkRect* dst = reinterpret_cast(dstPtr); auto constraint = SkCanvas::kStrict_SrcRectConstraint; // TODO: get from caller self.drawImageRect(image.get(), *src, *dst, SkSamplingOptions({B, C}), paint, constraint); }), allow_raw_pointers()) .function("_drawImageRectOptions", optional_override([](SkCanvas& self, const sk_sp& image, WASMPointerF32 srcPtr, WASMPointerF32 dstPtr, SkFilterMode filter, SkMipmapMode mipmap, const SkPaint* paint)->void { const SkRect* src = reinterpret_cast(srcPtr); const SkRect* dst = reinterpret_cast(dstPtr); auto constraint = SkCanvas::kStrict_SrcRectConstraint; // TODO: get from caller self.drawImageRect(image.get(), *src, *dst, {filter, mipmap}, paint, constraint); }), allow_raw_pointers()) .function("_drawLine", select_overload(&SkCanvas::drawLine)) .function("_drawOval", optional_override([](SkCanvas& self, WASMPointerF32 fPtr, const SkPaint& paint)->void { const SkRect* oval = reinterpret_cast(fPtr); self.drawOval(*oval, paint); })) .function("_drawPaint", &SkCanvas::drawPaint) #ifdef CK_INCLUDE_PARAGRAPH .function("_drawParagraph", optional_override([](SkCanvas& self, skia::textlayout::Paragraph* p, SkScalar x, SkScalar y) { p->paint(&self, x, y); }), allow_raw_pointers()) #endif .function("_drawPath", &SkCanvas::drawPath) .function("_drawPatch", optional_override([](SkCanvas& self, WASMPointerF32 cubics, WASMPointerU32 colors, WASMPointerF32 texs, SkBlendMode mode, const SkPaint& paint)->void { self.drawPatch(reinterpret_cast(cubics), reinterpret_cast(colors), reinterpret_cast(texs), mode, paint); })) // Of note, picture is *not* what is colloquially thought of as a "picture", what we call // a bitmap. An SkPicture is a series of draw commands. .function("_drawPicture", select_overload&)>(&SkCanvas::drawPicture)) .function("_drawPoints", optional_override([](SkCanvas& self, SkCanvas::PointMode mode, WASMPointerF32 pptr, int count, SkPaint& paint)->void { const SkPoint* pts = reinterpret_cast(pptr); self.drawPoints(mode, count, pts, paint); })) .function("_drawRRect",optional_override([](SkCanvas& self, WASMPointerF32 fPtr, const SkPaint& paint) { self.drawRRect(ptrToSkRRect(fPtr), paint); })) .function("_drawRect", optional_override([](SkCanvas& self, WASMPointerF32 fPtr, const SkPaint& paint)->void { const SkRect* rect = reinterpret_cast(fPtr); self.drawRect(*rect, paint); })) .function("_drawRect4f", optional_override([](SkCanvas& self, SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, const SkPaint& paint)->void { const SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); self.drawRect(rect, paint); })) .function("_drawShadow", optional_override([](SkCanvas& self, const SkPath& path, WASMPointerF32 zPlaneParamPtr, WASMPointerF32 lightPosPtr, SkScalar lightRadius, WASMPointerF32 ambientColorPtr, WASMPointerF32 spotColorPtr, uint32_t flags) { const SkVector3* zPlaneParams = reinterpret_cast(zPlaneParamPtr); const SkVector3* lightPos = reinterpret_cast(lightPosPtr); SkShadowUtils::DrawShadow(&self, path, *zPlaneParams, *lightPos, lightRadius, ptrToSkColor4f(ambientColorPtr).toSkColor(), ptrToSkColor4f(spotColorPtr).toSkColor(), flags); })) #ifndef CK_NO_FONTS .function("_drawSimpleText", optional_override([](SkCanvas& self, WASMPointerU8 sptr, size_t len, SkScalar x, SkScalar y, const SkFont& font, const SkPaint& paint) { const char* str = reinterpret_cast(sptr); self.drawSimpleText(str, len, SkTextEncoding::kUTF8, x, y, font, paint); })) .function("_drawTextBlob", select_overload&, SkScalar, SkScalar, const SkPaint&)>(&SkCanvas::drawTextBlob)) #endif .function("_drawVertices", select_overload&, SkBlendMode, const SkPaint&)>(&SkCanvas::drawVertices)) .function("_getDeviceClipBounds", optional_override([](const SkCanvas& self, WASMPointerI32 iPtr) { SkIRect* outputRect = reinterpret_cast(iPtr); if (!outputRect) { return; // output pointer cannot be null } self.getDeviceClipBounds(outputRect); })) // 4x4 matrix functions // Just like with getTotalMatrix, we allocate the buffer for the 16 floats to go in from // interface.js, so it can also free them when its done. .function("_getLocalToDevice", optional_override([](const SkCanvas& self, WASMPointerF32 mPtr) { SkScalar* sixteenMatrixValues = reinterpret_cast(mPtr); if (!sixteenMatrixValues) { return; // matrix cannot be null } SkM44 m = self.getLocalToDevice(); m.getRowMajor(sixteenMatrixValues); })) .function("getSaveCount", &SkCanvas::getSaveCount) // We allocate room for the matrix from the JS side and free it there so as to not have // an awkward moment where we malloc something here and "just know" to free it on the // JS side. .function("_getTotalMatrix", optional_override([](const SkCanvas& self, WASMPointerU8 mPtr) { SkScalar* nineMatrixValues = reinterpret_cast(mPtr); if (!nineMatrixValues) { return; // matrix cannot be null } SkMatrix m = self.getTotalMatrix(); m.get9(nineMatrixValues); })) .function("_makeSurface", optional_override([](SkCanvas& self, SimpleImageInfo sii)->sk_sp { return self.makeSurface(toSkImageInfo(sii), nullptr); }), allow_raw_pointers()) .function("_readPixels", optional_override([](SkCanvas& self, SimpleImageInfo di, WASMPointerU8 pPtr, size_t dstRowBytes, int srcX, int srcY) { uint8_t* pixels = reinterpret_cast(pPtr); SkImageInfo dstInfo = toSkImageInfo(di); return self.readPixels(dstInfo, pixels, dstRowBytes, srcX, srcY); }), allow_raw_pointers()) .function("restore", &SkCanvas::restore) .function("restoreToCount", &SkCanvas::restoreToCount) .function("rotate", select_overload(&SkCanvas::rotate)) .function("save", &SkCanvas::save) .function("_saveLayer", optional_override([](SkCanvas& self, const SkPaint* p, WASMPointerF32 fPtr, const SkImageFilter* backdrop, SkCanvas::SaveLayerFlags flags)->int { SkRect* bounds = reinterpret_cast(fPtr); return self.saveLayer(SkCanvas::SaveLayerRec(bounds, p, backdrop, flags)); }), allow_raw_pointers()) .function("saveLayerPaint", optional_override([](SkCanvas& self, const SkPaint p)->int { return self.saveLayer(SkCanvas::SaveLayerRec(nullptr, &p, 0)); })) .function("scale", &SkCanvas::scale) .function("skew", &SkCanvas::skew) .function("translate", &SkCanvas::translate) .function("_writePixels", optional_override([](SkCanvas& self, SimpleImageInfo di, WASMPointerU8 pPtr, size_t srcRowBytes, int dstX, int dstY) { uint8_t* pixels = reinterpret_cast(pPtr); SkImageInfo dstInfo = toSkImageInfo(di); return self.writePixels(dstInfo, pixels, srcRowBytes, dstX, dstY); })); class_("ColorFilter") .smart_ptr>("sk_sp>") .class_function("_MakeBlend", optional_override([](WASMPointerF32 cPtr, SkBlendMode mode, sk_sp colorSpace)->sk_sp { return SkColorFilters::Blend(ptrToSkColor4f(cPtr), colorSpace, mode); })) .class_function("MakeCompose", &SkColorFilters::Compose) .class_function("MakeLerp", &SkColorFilters::Lerp) .class_function("MakeLinearToSRGBGamma", &SkColorFilters::LinearToSRGBGamma) .class_function("_makeMatrix", optional_override([](WASMPointerF32 fPtr) { float* twentyFloats = reinterpret_cast(fPtr); return SkColorFilters::Matrix(twentyFloats); })) .class_function("MakeSRGBToLinearGamma", &SkColorFilters::SRGBToLinearGamma) .class_function("MakeLuma", &SkLumaColorFilter::Make); class_("ContourMeasureIter") .constructor() .function("next", &SkContourMeasureIter::next); class_("ContourMeasure") .smart_ptr>("sk_sp>") .function("_getPosTan", optional_override([](SkContourMeasure& self, SkScalar distance, WASMPointerF32 oPtr) -> void { SkPoint* pointAndVector = reinterpret_cast(oPtr); if (!self.getPosTan(distance, pointAndVector, pointAndVector + 1)) { SkDebugf("zero-length path in getPosTan\n"); } })) .function("getSegment", optional_override([](SkContourMeasure& self, SkScalar startD, SkScalar stopD, bool startWithMoveTo) -> SkPath { SkPath p; bool ok = self.getSegment(startD, stopD, &p, startWithMoveTo); if (ok) { return p; } return SkPath(); })) .function("isClosed", &SkContourMeasure::isClosed) .function("length", &SkContourMeasure::length); #ifndef CK_NO_FONTS class_("Font") .constructor<>() .constructor>() .constructor, SkScalar>() .constructor, SkScalar, SkScalar, SkScalar>() .function("_getGlyphWidthBounds", optional_override([](SkFont& self, WASMPointerU16 gPtr, int numGlyphs, WASMPointerF32 wPtr, WASMPointerF32 rPtr, SkPaint* paint) { const SkGlyphID* glyphs = reinterpret_cast(gPtr); // On the JS side only one of these is set at a time for easier ergonomics. SkRect* outputRects = reinterpret_cast(rPtr); SkScalar* outputWidths = reinterpret_cast(wPtr); self.getWidthsBounds(glyphs, numGlyphs, outputWidths, outputRects, paint); }), allow_raw_pointers()) .function("_getGlyphIDs", optional_override([](SkFont& self, WASMPointerU8 sptr, size_t strLen, size_t expectedCodePoints, WASMPointerU16 iPtr) -> int { char* str = reinterpret_cast(sptr); SkGlyphID* glyphIDs = reinterpret_cast(iPtr); int actualCodePoints = self.textToGlyphs(str, strLen, SkTextEncoding::kUTF8, glyphIDs, expectedCodePoints); return actualCodePoints; })) .function("getMetrics", optional_override([](SkFont& self) -> JSObject { SkFontMetrics fm; self.getMetrics(&fm); JSObject j = emscripten::val::object(); j.set("ascent", fm.fAscent); j.set("descent", fm.fDescent); j.set("leading", fm.fLeading); if (!(fm.fFlags & SkFontMetrics::kBoundsInvalid_Flag)) { const float rect[] = { fm.fXMin, fm.fTop, fm.fXMax, fm.fBottom }; j.set("bounds", MakeTypedArray(4, rect)); } return j; })) .function("_getGlyphIntercepts", optional_override([](SkFont& self, WASMPointerU16 gPtr, size_t numGlyphs, bool ownGlyphs, WASMPointerF32 pPtr, size_t numPos, bool ownPos, float top, float bottom) -> Float32Array { JSSpan glyphs(gPtr, numGlyphs, ownGlyphs); JSSpan pos (pPtr, numPos, ownPos); if (glyphs.size() > (pos.size() >> 1)) { return emscripten::val("Not enough x,y position pairs for glyphs"); } auto sects = self.getIntercepts(glyphs.data(), SkToInt(glyphs.size()), (const SkPoint*)pos.data(), top, bottom); return MakeTypedArray(sects.size(), (const float*)sects.data()); }), allow_raw_pointers()) .function("getScaleX", &SkFont::getScaleX) .function("getSize", &SkFont::getSize) .function("getSkewX", &SkFont::getSkewX) .function("isEmbolden", &SkFont::isEmbolden) .function("getTypeface", &SkFont::getTypeface, allow_raw_pointers()) .function("setEdging", &SkFont::setEdging) .function("setEmbeddedBitmaps", &SkFont::setEmbeddedBitmaps) .function("setHinting", &SkFont::setHinting) .function("setLinearMetrics", &SkFont::setLinearMetrics) .function("setScaleX", &SkFont::setScaleX) .function("setSize", &SkFont::setSize) .function("setSkewX", &SkFont::setSkewX) .function("setEmbolden", &SkFont::setEmbolden) .function("setSubpixel", &SkFont::setSubpixel) .function("setTypeface", &SkFont::setTypeface, allow_raw_pointers()); class_("FontMgr") .smart_ptr>("sk_sp") .class_function("_fromData", optional_override([](WASMPointerU32 dPtr, WASMPointerU32 sPtr, int numFonts)->sk_sp { auto datas = reinterpret_cast(dPtr); auto sizes = reinterpret_cast(sPtr); std::unique_ptr[]> skdatas(new sk_sp[numFonts]); for (int i = 0; i < numFonts; ++i) { skdatas[i] = SkData::MakeFromMalloc(datas[i], sizes[i]); } return SkFontMgr_New_Custom_Data(SkSpan(skdatas.get(), numFonts)); }), allow_raw_pointers()) .function("countFamilies", &SkFontMgr::countFamilies) .function("getFamilyName", optional_override([](SkFontMgr& self, int index)->JSString { if (index < 0 || index >= self.countFamilies()) { return emscripten::val::null(); } SkString s; self.getFamilyName(index, &s); return emscripten::val(s.c_str()); })) .function("matchFamilyStyle", optional_override([](SkFontMgr& self, std::string name, emscripten::val jsFontStyle)->sk_sp { auto weight = SkFontStyle::Weight(jsFontStyle["weight"].isUndefined() ? SkFontStyle::kNormal_Weight : jsFontStyle["weight"].as()); auto width = SkFontStyle::Width(jsFontStyle["width"].isUndefined() ? SkFontStyle::kNormal_Width : jsFontStyle["width"].as()); auto slant = SkFontStyle::Slant(jsFontStyle["slant"].isUndefined() ? SkFontStyle::kUpright_Slant : static_cast(jsFontStyle["slant"].as())); SkFontStyle style(weight, width, slant); return self.matchFamilyStyle(name.c_str(), style); }), allow_raw_pointers()) #ifdef SK_DEBUG .function("dumpFamilies", optional_override([](SkFontMgr& self) { int numFam = self.countFamilies(); SkDebugf("There are %d font families\n", numFam); for (int i = 0 ; i< numFam; i++) { SkString s; self.getFamilyName(i, &s); SkDebugf("\t%s\n", s.c_str()); } })) #endif .function("_makeTypefaceFromData", optional_override([](SkFontMgr& self, WASMPointerU8 fPtr, int flen)->sk_sp { uint8_t* font = reinterpret_cast(fPtr); sk_sp fontData = SkData::MakeFromMalloc(font, flen); return self.makeFromData(fontData); }), allow_raw_pointers()); #endif // CK_NO_FONTS class_("Image") .smart_ptr>("sk_sp") #ifdef CK_ENABLE_WEBGL .class_function("_makeFromGenerator", &MakeImageFromGenerator) #endif // Note that this needs to be cleaned up with delete(). .function("getColorSpace", optional_override([](sk_sp self)->sk_sp { return self->imageInfo().refColorSpace(); }), allow_raw_pointers()) .function("getImageInfo", optional_override([](sk_sp self)->JSObject { // We cannot return a SimpleImageInfo because the colorspace object would be leaked. JSObject result = emscripten::val::object(); SkImageInfo ii = self->imageInfo(); result.set("alphaType", ii.alphaType()); result.set("colorType", ii.colorType()); result.set("height", ii.height()); result.set("width", ii.width()); return result; })) .function("height", &SkImage::height) .function("_encodeToBytes", optional_override([](sk_sp self, SkEncodedImageFormat fmt, int quality) -> Uint8Array { return encodeImage(nullptr, self, fmt, quality); })) #if defined(ENABLE_GPU) .function("_encodeToBytes", optional_override([](sk_sp self, SkEncodedImageFormat fmt, int quality, GrDirectContext* dContext) -> Uint8Array { return encodeImage(dContext, self, fmt, quality); }), allow_raw_pointers()) #endif .function("makeCopyWithDefaultMipmaps", optional_override([](sk_sp self)->sk_sp { return self->withDefaultMipmaps(); })) .function("_makeShaderCubic", optional_override([](sk_sp self, SkTileMode tx, SkTileMode ty, float B, float C, // See SkSamplingOptions.h for docs. WASMPointerF32 mPtr)->sk_sp { OptionalMatrix localMatrix(mPtr); return self->makeShader(tx, ty, SkSamplingOptions({B, C}), mPtr ? &localMatrix : nullptr); }), allow_raw_pointers()) .function("_makeShaderOptions", optional_override([](sk_sp self, SkTileMode tx, SkTileMode ty, SkFilterMode filter, SkMipmapMode mipmap, WASMPointerF32 mPtr)->sk_sp { OptionalMatrix localMatrix(mPtr); return self->makeShader(tx, ty, {filter, mipmap}, mPtr ? &localMatrix : nullptr); }), allow_raw_pointers()) #if defined(ENABLE_GPU) .function("_readPixels", optional_override([](sk_sp self, SimpleImageInfo sii, WASMPointerU8 pPtr, size_t dstRowBytes, int srcX, int srcY, GrDirectContext* dContext)->bool { uint8_t* pixels = reinterpret_cast(pPtr); SkImageInfo ii = toSkImageInfo(sii); return self->readPixels(dContext, ii, pixels, dstRowBytes, srcX, srcY); }), allow_raw_pointers()) #endif .function("_readPixels", optional_override([](sk_sp self, SimpleImageInfo sii, WASMPointerU8 pPtr, size_t dstRowBytes, int srcX, int srcY)->bool { uint8_t* pixels = reinterpret_cast(pPtr); SkImageInfo ii = toSkImageInfo(sii); return self->readPixels(nullptr, ii, pixels, dstRowBytes, srcX, srcY); }), allow_raw_pointers()) .function("width", &SkImage::width); class_("ImageFilter") .smart_ptr>("sk_sp") .function("_getOutputBounds", optional_override([](const SkImageFilter& self, WASMPointerF32 bPtr, WASMPointerF32 mPtr, WASMPointerU32 oPtr)->void { SkRect* rect = reinterpret_cast(bPtr); OptionalMatrix ctm(mPtr); SkIRect* output = reinterpret_cast(oPtr); output[0] = self.filterBounds(ctm.mapRect(*rect).roundOut(), ctm, SkImageFilter::kForward_MapDirection); })) .class_function("MakeBlend", optional_override([](SkBlendMode mode, sk_sp background, sk_sp foreground)->sk_sp { return SkImageFilters::Blend(mode, background, foreground); })) .class_function("MakeBlur", optional_override([](SkScalar sigmaX, SkScalar sigmaY, SkTileMode tileMode, sk_sp input)->sk_sp { return SkImageFilters::Blur(sigmaX, sigmaY, tileMode, input); })) .class_function("MakeColorFilter", optional_override([](sk_sp cf, sk_sp input)->sk_sp { return SkImageFilters::ColorFilter(cf, input); })) .class_function("MakeCompose", &SkImageFilters::Compose) .class_function("MakeDilate", optional_override([](SkScalar radiusX, SkScalar radiusY, sk_sp input)->sk_sp { return SkImageFilters::Dilate(radiusX, radiusY, input); })) .class_function("MakeDisplacementMap", optional_override([](SkColorChannel xChannelSelector, SkColorChannel yChannelSelector, SkScalar scale, sk_sp displacement, sk_sp color)->sk_sp { return SkImageFilters::DisplacementMap(xChannelSelector, yChannelSelector, scale, displacement, color); })) .class_function("MakeShader", optional_override([](sk_sp shader)->sk_sp { return SkImageFilters::Shader(shader); })) .class_function("_MakeDropShadow", optional_override([](SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, WASMPointerF32 cPtr, sk_sp input)->sk_sp { SkColor4f c = ptrToSkColor4f(cPtr); return SkImageFilters::DropShadow(dx, dy, sigmaX, sigmaY, c.toSkColor(), input); })) .class_function("_MakeDropShadowOnly", optional_override([](SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, WASMPointerF32 cPtr, sk_sp input)->sk_sp { SkColor4f c = ptrToSkColor4f(cPtr); return SkImageFilters::DropShadowOnly(dx, dy, sigmaX, sigmaY, c.toSkColor(), input); })) .class_function("MakeErode", optional_override([](SkScalar radiusX, SkScalar radiusY, sk_sp input)->sk_sp { return SkImageFilters::Erode(radiusX, radiusY, input); })) .class_function("_MakeImageCubic", optional_override([](sk_sp image, float B, float C, WASMPointerF32 srcPtr, WASMPointerF32 dstPtr )->sk_sp { const SkRect* src = reinterpret_cast(srcPtr); const SkRect* dst = reinterpret_cast(dstPtr); if (src && dst) { return SkImageFilters::Image(image, *src, *dst, SkSamplingOptions({B, C})); } return SkImageFilters::Image(image, SkSamplingOptions({B, C})); })) .class_function("_MakeImageOptions", optional_override([](sk_sp image, SkFilterMode fm, SkMipmapMode mm, WASMPointerF32 srcPtr, WASMPointerF32 dstPtr )->sk_sp { const SkRect* src = reinterpret_cast(srcPtr); const SkRect* dst = reinterpret_cast(dstPtr); if (src && dst) { return SkImageFilters::Image(image, *src, *dst, SkSamplingOptions(fm, mm)); } return SkImageFilters::Image(image, SkSamplingOptions(fm, mm)); })) .class_function("_MakeMatrixTransformCubic", optional_override([](WASMPointerF32 mPtr, float B, float C, sk_sp input)->sk_sp { OptionalMatrix matr(mPtr); return SkImageFilters::MatrixTransform(matr, SkSamplingOptions({B, C}), input); })) .class_function("_MakeMatrixTransformOptions", optional_override([](WASMPointerF32 mPtr, SkFilterMode fm, SkMipmapMode mm, sk_sp input)->sk_sp { OptionalMatrix matr(mPtr); return SkImageFilters::MatrixTransform(matr, SkSamplingOptions(fm, mm), input); })) .class_function("MakeOffset", optional_override([](SkScalar dx, SkScalar dy, sk_sp input)->sk_sp { return SkImageFilters::Offset(dx, dy, input); })); class_("MaskFilter") .smart_ptr>("sk_sp") .class_function("MakeBlur", optional_override([](SkBlurStyle style, SkScalar sigma, bool respectCTM)->sk_sp { // Adds a little helper because emscripten doesn't expose default params. return SkMaskFilter::MakeBlur(style, sigma, respectCTM); }), allow_raw_pointers()); class_("Paint") .constructor<>() .function("copy", optional_override([](const SkPaint& self)->SkPaint { SkPaint p(self); return p; })) // provide an allocated place to put the returned color .function("_getColor", optional_override([](SkPaint& self, WASMPointerF32 cPtr)->void { const SkColor4f& c = self.getColor4f(); float* fourFloats = reinterpret_cast(cPtr); memcpy(fourFloats, c.vec(), 4 * sizeof(SkScalar)); })) .function("getStrokeCap", &SkPaint::getStrokeCap) .function("getStrokeJoin", &SkPaint::getStrokeJoin) .function("getStrokeMiter", &SkPaint::getStrokeMiter) .function("getStrokeWidth", &SkPaint::getStrokeWidth) .function("setAntiAlias", &SkPaint::setAntiAlias) .function("setAlphaf", &SkPaint::setAlphaf) .function("setBlendMode", &SkPaint::setBlendMode) .function("setBlender", &SkPaint::setBlender) .function("_setColor", optional_override([](SkPaint& self, WASMPointerF32 cPtr, sk_sp colorSpace) { self.setColor(ptrToSkColor4f(cPtr), colorSpace.get()); })) .function("setColorInt", optional_override([](SkPaint& self, SkColor color) { self.setColor(SkColor4f::FromColor(color), nullptr); })) .function("setColorInt", optional_override([](SkPaint& self, SkColor color, sk_sp colorSpace) { self.setColor(SkColor4f::FromColor(color), colorSpace.get()); })) .function("setColorFilter", &SkPaint::setColorFilter) .function("setDither", &SkPaint::setDither) .function("setImageFilter", &SkPaint::setImageFilter) .function("setMaskFilter", &SkPaint::setMaskFilter) .function("setPathEffect", &SkPaint::setPathEffect) .function("setShader", &SkPaint::setShader) .function("setStrokeCap", &SkPaint::setStrokeCap) .function("setStrokeJoin", &SkPaint::setStrokeJoin) .function("setStrokeMiter", &SkPaint::setStrokeMiter) .function("setStrokeWidth", &SkPaint::setStrokeWidth) .function("setStyle", &SkPaint::setStyle); class_("ColorSpace") .smart_ptr>("sk_sp") .class_function("Equals", optional_override([](sk_sp a, sk_sp b)->bool { return SkColorSpace::Equals(a.get(), b.get()); })) // These are private because they are to be called once in interface.js to // avoid clients having to delete the returned objects. .class_function("_MakeSRGB", &SkColorSpace::MakeSRGB) .class_function("_MakeDisplayP3", optional_override([]()->sk_sp { return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDisplayP3); })) .class_function("_MakeAdobeRGB", optional_override([]()->sk_sp { return SkColorSpace::MakeRGB(SkNamedTransferFn::k2Dot2, SkNamedGamut::kAdobeRGB); })); class_("PathEffect") .smart_ptr>("sk_sp") .class_function("MakeCorner", &SkCornerPathEffect::Make) .class_function("_MakeDash", optional_override([](WASMPointerF32 cptr, int count, SkScalar phase)->sk_sp { const float* intervals = reinterpret_cast(cptr); return SkDashPathEffect::Make(intervals, count, phase); }), allow_raw_pointers()) .class_function("MakeDiscrete", &SkDiscretePathEffect::Make) .class_function("_MakeLine2D", optional_override([](SkScalar width, WASMPointerF32 mPtr)->sk_sp { SkMatrix matrix; const SkScalar* nineMatrixValues = reinterpret_cast(mPtr); matrix.set9(nineMatrixValues); return SkLine2DPathEffect::Make(width, matrix); }), allow_raw_pointers()) .class_function("MakePath1D", &SkPath1DPathEffect::Make) .class_function("_MakePath2D", optional_override([](WASMPointerF32 mPtr, SkPath path)->sk_sp { SkMatrix matrix; const SkScalar* nineMatrixValues = reinterpret_cast(mPtr); matrix.set9(nineMatrixValues); return SkPath2DPathEffect::Make(matrix, path); }), allow_raw_pointers()); // TODO(kjlubick, reed) Make SkPath immutable and only creatable via a factory/builder. class_("Path") .constructor<>() #ifdef CK_INCLUDE_PATHOPS .class_function("MakeFromOp", &MakePathFromOp) #endif .class_function("MakeFromSVGString", &MakePathFromSVGString) .class_function("MakeFromPathInterpolation", &MakePathFromInterpolation) .class_function("CanInterpolate", &CanInterpolate) .class_function("_MakeFromCmds", &MakePathFromCmds) .class_function("_MakeFromVerbsPointsWeights", &MakePathFromVerbsPointsWeights) .function("_addArc", optional_override([](SkPath& self, WASMPointerF32 fPtr, SkScalar startAngle, SkScalar sweepAngle)->void { const SkRect* oval = reinterpret_cast(fPtr); self.addArc(*oval, startAngle, sweepAngle); })) .function("_addOval", optional_override([](SkPath& self, WASMPointerF32 fPtr, bool ccw, unsigned start)->void { const SkRect* oval = reinterpret_cast(fPtr); self.addOval(*oval, ccw ? SkPathDirection::kCCW : SkPathDirection::kCW, start); })) .function("_addCircle", optional_override([](SkPath& self, SkScalar x, SkScalar y, SkScalar r, bool ccw)->void { self.addCircle(x, y, r, ccw ? SkPathDirection::kCCW : SkPathDirection::kCW); })) // interface.js has 3 overloads of addPath .function("_addPath", &ApplyAddPath) .function("_addPoly", optional_override([](SkPath& self, WASMPointerF32 fPtr, int count, bool close)->void { const SkPoint* pts = reinterpret_cast(fPtr); self.addPoly(pts, count, close); })) .function("_addRect", optional_override([](SkPath& self, WASMPointerF32 fPtr, bool ccw)->void { const SkRect* rect = reinterpret_cast(fPtr); self.addRect(*rect, ccw ? SkPathDirection::kCCW : SkPathDirection::kCW); })) .function("_addRRect", optional_override([](SkPath& self, WASMPointerF32 fPtr, bool ccw)->void { self.addRRect(ptrToSkRRect(fPtr), ccw ? SkPathDirection::kCCW : SkPathDirection::kCW); })) .function("_addVerbsPointsWeights", &PathAddVerbsPointsWeights) .function("_arcToOval", optional_override([](SkPath& self, WASMPointerF32 fPtr, SkScalar startAngle, SkScalar sweepAngle, bool forceMoveTo)->void { const SkRect* oval = reinterpret_cast(fPtr); self.arcTo(*oval, startAngle, sweepAngle, forceMoveTo); })) .function("_arcToRotated", &ApplyArcToArcSize) .function("_arcToTangent", ApplyArcToTangent) .function("_close", &ApplyClose) .function("_conicTo", &ApplyConicTo) .function("countPoints", &SkPath::countPoints) .function("contains", &SkPath::contains) .function("_cubicTo", &ApplyCubicTo) .function("_getPoint", optional_override([](SkPath& self, int index, WASMPointerF32 oPtr)->void { SkPoint* output = reinterpret_cast(oPtr); *output = self.getPoint(index); })) .function("isEmpty", &SkPath::isEmpty) .function("isVolatile", &SkPath::isVolatile) .function("_lineTo", &ApplyLineTo) .function("_moveTo", &ApplyMoveTo) .function("_quadTo", &ApplyQuadTo) .function("_rArcTo", &ApplyRArcToArcSize) .function("_rConicTo", &ApplyRConicTo) .function("_rCubicTo", &ApplyRCubicTo) .function("_rLineTo", &ApplyRLineTo) .function("_rMoveTo", &ApplyRMoveTo) .function("_rQuadTo", &ApplyRQuadTo) .function("reset", &ApplyReset) .function("rewind", &ApplyRewind) .function("setIsVolatile", &SkPath::setIsVolatile) .function("_transform", select_overload(&ApplyTransform)) // PathEffects .function("_dash", &ApplyDash) .function("_trim", &ApplyTrim) .function("_stroke", &ApplyStroke) #ifdef CK_INCLUDE_PATHOPS // PathOps .function("_simplify", &ApplySimplify) .function("_op", &ApplyPathOp) .function("makeAsWinding", &MakeAsWinding) #endif // Exporting .function("toSVGString", &ToSVGString) .function("toCmds", &ToCmds) .function("setFillType", select_overload(&SkPath::setFillType)) .function("getFillType", &SkPath::getFillType) .function("_getBounds", optional_override([](SkPath& self, WASMPointerF32 fPtr)->void { SkRect* output = reinterpret_cast(fPtr); output[0] = self.getBounds(); })) .function("_computeTightBounds", optional_override([](SkPath& self, WASMPointerF32 fPtr)->void { SkRect* output = reinterpret_cast(fPtr); output[0] = self.computeTightBounds(); })) .function("equals", &Equals) .function("copy", &CopyPath) #ifdef SK_DEBUG .function("dump", select_overload(&SkPath::dump)) .function("dumpHex", select_overload(&SkPath::dumpHex)) #endif ; static SkRTreeFactory bbhFactory; class_("PictureRecorder") .constructor<>() .function("_beginRecording", optional_override([](SkPictureRecorder& self, WASMPointerF32 fPtr, bool computeBounds) -> SkCanvas* { SkRect* bounds = reinterpret_cast(fPtr); return self.beginRecording(*bounds, computeBounds ? &bbhFactory : nullptr); }), allow_raw_pointers()) .function("finishRecordingAsPicture", optional_override([](SkPictureRecorder& self) -> sk_sp { return self.finishRecordingAsPicture(); }), allow_raw_pointers()); class_("Picture") .smart_ptr>("sk_sp") .function("_makeShader", optional_override([](SkPicture& self, SkTileMode tmx, SkTileMode tmy, SkFilterMode mode, WASMPointerF32 mPtr, WASMPointerF32 rPtr) -> sk_sp { OptionalMatrix localMatrix(mPtr); SkRect* tileRect = reinterpret_cast(rPtr); return self.makeShader(tmx, tmy, mode, mPtr ? &localMatrix : nullptr, tileRect); }), allow_raw_pointers()) .function("_cullRect", optional_override([](SkPicture& self, WASMPointerF32 fPtr)->void { SkRect* output = reinterpret_cast(fPtr); output[0] = self.cullRect(); })) .function("approximateBytesUsed", &SkPicture::approximateBytesUsed) #ifdef CK_SERIALIZE_SKP // The serialized format of an SkPicture (informally called an "skp"), is not something // that clients should ever rely on. The format may change at anytime and no promises // are made for backwards or forward compatibility. .function("serialize", optional_override([](SkPicture& self) -> Uint8Array { // We want to make sure we always save the underlying data of the Typeface to the // SkPicture. By default, the data for "system" fonts is not saved, just an identifier // (e.g. the family name and style). We do not want the user to have to supply a // FontMgr with the correct fonts by name when deserializing, so we choose to always // serialize the underlying data. This makes the SKPs a bit bigger, but easier to use. SkSerialProcs sp; sp.fTypefaceProc = &alwaysSaveTypefaceBytes; sp.fImageProc = [](SkImage* img, void*) -> sk_sp { return SkPngEncoder::Encode(nullptr, img, SkPngEncoder::Options{}); }; sk_sp data = self.serialize(&sp); if (!data) { return emscripten::val::null(); } return toBytes(data); }), allow_raw_pointers()) #endif ; class_("Shader") .smart_ptr>("sk_sp") .class_function("MakeBlend", select_overload(SkBlendMode, sk_sp, sk_sp)>(&SkShaders::Blend)) .class_function("_MakeColor", optional_override([](WASMPointerF32 cPtr, sk_sp colorSpace)->sk_sp { return SkShaders::Color(ptrToSkColor4f(cPtr), colorSpace); }) ) .class_function("MakeFractalNoise", optional_override([]( SkScalar baseFreqX, SkScalar baseFreqY, int numOctaves, SkScalar seed, int tileW, int tileH)->sk_sp { // if tileSize is empty (e.g. tileW <= 0 or tileH <= 0, it will be ignored. SkISize tileSize = SkISize::Make(tileW, tileH); return SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, numOctaves, seed, &tileSize); })) // Here and in other gradient functions, cPtr is a pointer to an array of data // representing colors. whether this is an array of SkColor or SkColor4f is indicated // by the colorType argument. Only RGBA_8888 and RGBA_F32 are accepted. .class_function("_MakeLinearGradient", optional_override([]( WASMPointerF32 fourFloatsPtr, WASMPointerF32 cPtr, SkColorType colorType, WASMPointerF32 pPtr, int count, SkTileMode mode, uint32_t flags, WASMPointerF32 mPtr, sk_sp colorSpace)->sk_sp { const SkPoint* points = reinterpret_cast(fourFloatsPtr); const SkScalar* positions = reinterpret_cast(pPtr); OptionalMatrix localMatrix(mPtr); if (colorType == SkColorType::kRGBA_F32_SkColorType) { const SkColor4f* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeLinear(points, colors, colorSpace, positions, count, mode, flags, mPtr ? &localMatrix : nullptr); } else if (colorType == SkColorType::kRGBA_8888_SkColorType) { const SkColor* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeLinear(points, colors, positions, count, mode, flags, mPtr ? &localMatrix : nullptr); } SkDebugf("%d is not an accepted colorType\n", colorType); return nullptr; }), allow_raw_pointers()) .class_function("_MakeRadialGradient", optional_override([]( SkScalar cx, SkScalar cy, SkScalar radius, WASMPointerF32 cPtr, SkColorType colorType, WASMPointerF32 pPtr, int count, SkTileMode mode, uint32_t flags, WASMPointerF32 mPtr, sk_sp colorSpace)->sk_sp { const SkScalar* positions = reinterpret_cast(pPtr); OptionalMatrix localMatrix(mPtr); if (colorType == SkColorType::kRGBA_F32_SkColorType) { const SkColor4f* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeRadial({cx, cy}, radius, colors, colorSpace, positions, count, mode, flags, mPtr ? &localMatrix : nullptr); } else if (colorType == SkColorType::kRGBA_8888_SkColorType) { const SkColor* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeRadial({cx, cy}, radius, colors, positions, count, mode, flags, mPtr ? &localMatrix : nullptr); } SkDebugf("%d is not an accepted colorType\n", colorType); return nullptr; }), allow_raw_pointers()) .class_function("_MakeSweepGradient", optional_override([](SkScalar cx, SkScalar cy, WASMPointerF32 cPtr, SkColorType colorType, WASMPointerF32 pPtr, int count, SkTileMode mode, SkScalar startAngle, SkScalar endAngle, uint32_t flags, WASMPointerF32 mPtr, sk_sp colorSpace)->sk_sp { const SkScalar* positions = reinterpret_cast(pPtr); OptionalMatrix localMatrix(mPtr); if (colorType == SkColorType::kRGBA_F32_SkColorType) { const SkColor4f* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeSweep(cx, cy, colors, colorSpace, positions, count, mode, startAngle, endAngle, flags, mPtr ? &localMatrix : nullptr); } else if (colorType == SkColorType::kRGBA_8888_SkColorType) { const SkColor* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeSweep(cx, cy, colors, positions, count, mode, startAngle, endAngle, flags, mPtr ? &localMatrix : nullptr); } SkDebugf("%d is not an accepted colorType\n", colorType); return nullptr; }), allow_raw_pointers()) .class_function("MakeTurbulence", optional_override([]( SkScalar baseFreqX, SkScalar baseFreqY, int numOctaves, SkScalar seed, int tileW, int tileH)->sk_sp { // if tileSize is empty (e.g. tileW <= 0 or tileH <= 0, it will be ignored. SkISize tileSize = SkISize::Make(tileW, tileH); return SkShaders::MakeTurbulence(baseFreqX, baseFreqY, numOctaves, seed, &tileSize); })) .class_function("_MakeTwoPointConicalGradient", optional_override([]( WASMPointerF32 fourFloatsPtr, SkScalar startRadius, SkScalar endRadius, WASMPointerF32 cPtr, SkColorType colorType, WASMPointerF32 pPtr, int count, SkTileMode mode, uint32_t flags, WASMPointerF32 mPtr, sk_sp colorSpace)->sk_sp { const SkPoint* startAndEnd = reinterpret_cast(fourFloatsPtr); const SkScalar* positions = reinterpret_cast(pPtr); OptionalMatrix localMatrix(mPtr); if (colorType == SkColorType::kRGBA_F32_SkColorType) { const SkColor4f* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeTwoPointConical(startAndEnd[0], startRadius, startAndEnd[1], endRadius, colors, colorSpace, positions, count, mode, flags, mPtr ? &localMatrix : nullptr); } else if (colorType == SkColorType::kRGBA_8888_SkColorType) { const SkColor* colors = reinterpret_cast(cPtr); return SkGradientShader::MakeTwoPointConical(startAndEnd[0], startRadius, startAndEnd[1], endRadius, colors, positions, count, mode, flags, mPtr ? &localMatrix : nullptr); } SkDebugf("%d is not an accepted colorType\n", colorType); return nullptr; }), allow_raw_pointers()); #ifdef CK_INCLUDE_RUNTIME_EFFECT class_("DebugTrace") .smart_ptr>("sk_sp") .function("writeTrace", optional_override([](SkSL::DebugTrace& self) -> std::string { SkDynamicMemoryWStream wstream; self.writeTrace(&wstream); sk_sp trace = wstream.detachAsData(); return std::string(reinterpret_cast(trace->bytes()), trace->size()); })); value_object("TracedShader") .field("shader", &SkRuntimeEffect::TracedShader::shader) .field("debugTrace", &SkRuntimeEffect::TracedShader::debugTrace); class_("RuntimeEffect") .smart_ptr>("sk_sp") .class_function("_Make", optional_override([](std::string sksl, emscripten::val errHandler )->sk_sp { SkString s(sksl.c_str(), sksl.length()); auto [effect, errorText] = SkRuntimeEffect::MakeForShader(s); if (!effect) { errHandler.call("onError", val(errorText.c_str())); return nullptr; } return effect; })) .class_function("_MakeForBlender", optional_override([](std::string sksl, emscripten::val errHandler )->sk_sp { SkString s(sksl.c_str(), sksl.length()); auto [effect, errorText] = SkRuntimeEffect::MakeForBlender(s); if (!effect) { errHandler.call("onError", val(errorText.c_str())); return nullptr; } return effect; })) .class_function("MakeTraced", optional_override([]( sk_sp shader, int traceCoordX, int traceCoordY) -> SkRuntimeEffect::TracedShader { return SkRuntimeEffect::MakeTraced(shader, SkIPoint::Make(traceCoordX, traceCoordY)); })) .function("_makeShader", optional_override([](SkRuntimeEffect& self, WASMPointerF32 fPtr, size_t fLen, bool shouldOwnUniforms, WASMPointerF32 mPtr)->sk_sp { void* uniformData = reinterpret_cast(fPtr); castUniforms(uniformData, fLen, self); sk_sp uniforms; if (shouldOwnUniforms) { uniforms = SkData::MakeFromMalloc(uniformData, fLen); } else { uniforms = SkData::MakeWithoutCopy(uniformData, fLen); } OptionalMatrix localMatrix(mPtr); return self.makeShader(uniforms, nullptr, 0, mPtr ? &localMatrix : nullptr); })) .function("_makeShaderWithChildren", optional_override([](SkRuntimeEffect& self, WASMPointerF32 fPtr, size_t fLen, bool shouldOwnUniforms, WASMPointerU32 cPtrs, size_t cLen, WASMPointerF32 mPtr)->sk_sp { void* uniformData = reinterpret_cast(fPtr); castUniforms(uniformData, fLen, self); sk_sp uniforms; if (shouldOwnUniforms) { uniforms = SkData::MakeFromMalloc(uniformData, fLen); } else { uniforms = SkData::MakeWithoutCopy(uniformData, fLen); } sk_sp* children = new sk_sp[cLen]; SkShader** childrenPtrs = reinterpret_cast(cPtrs); for (size_t i = 0; i < cLen; i++) { // This bare pointer was already part of an sk_sp (owned outside of here), // so we want to ref the new sk_sp so makeShader doesn't clean it up. children[i] = sk_ref_sp(childrenPtrs[i]); } OptionalMatrix localMatrix(mPtr); auto s = self.makeShader(uniforms, children, cLen, mPtr ? &localMatrix : nullptr); delete[] children; return s; })) .function("_makeBlender", optional_override([](SkRuntimeEffect& self, WASMPointerF32 fPtr, size_t fLen, bool shouldOwnUniforms)->sk_sp { void* uniformData = reinterpret_cast(fPtr); castUniforms(uniformData, fLen, self); sk_sp uniforms; if (shouldOwnUniforms) { uniforms = SkData::MakeFromMalloc(uniformData, fLen); } else { uniforms = SkData::MakeWithoutCopy(uniformData, fLen); } return self.makeBlender(uniforms, {}); })) .function("getUniformCount", optional_override([](SkRuntimeEffect& self)->int { return self.uniforms().size(); })) .function("getUniformFloatCount", optional_override([](SkRuntimeEffect& self)->int { return self.uniformSize() / sizeof(float); })) .function("getUniformName", optional_override([](SkRuntimeEffect& self, int i)->JSString { auto it = self.uniforms().begin() + i; return emscripten::val(std::string(it->name).c_str()); })) .function("getUniform", optional_override([](SkRuntimeEffect& self, int i)->RuntimeEffectUniform { auto it = self.uniforms().begin() + i; RuntimeEffectUniform su = fromUniform(*it); return su; })); value_object("RuntimeEffectUniform") .field("columns", &RuntimeEffectUniform::columns) .field("rows", &RuntimeEffectUniform::rows) .field("slot", &RuntimeEffectUniform::slot) .field("isInteger", &RuntimeEffectUniform::isInteger); constant("rt_effect", true); #endif class_("Surface") .smart_ptr>("sk_sp") .class_function("_makeRasterDirect", optional_override([](const SimpleImageInfo ii, WASMPointerU8 pPtr, size_t rowBytes)->sk_sp { uint8_t* pixels = reinterpret_cast(pPtr); SkImageInfo imageInfo = toSkImageInfo(ii); return SkSurfaces::WrapPixels(imageInfo, pixels, rowBytes, nullptr); }), allow_raw_pointers()) .function("_flush", optional_override([](SkSurface& self) { #ifdef CK_ENABLE_WEBGL skgpu::ganesh::FlushAndSubmit(&self); #endif })) .function("_getCanvas", &SkSurface::getCanvas, allow_raw_pointers()) .function("imageInfo", optional_override([](SkSurface& self)->SimpleImageInfo { const auto& ii = self.imageInfo(); return {ii.width(), ii.height(), ii.colorType(), ii.alphaType(), ii.refColorSpace()}; })) .function("height", &SkSurface::height) #ifdef CK_ENABLE_WEBGL .function("_makeImageFromTexture", optional_override([](SkSurface& self, uint32_t webglHandle, uint32_t texHandle, SimpleImageInfo ii)->sk_sp { auto releaseCtx = new TextureReleaseContext{webglHandle, texHandle}; GrGLTextureInfo gti = {GR_GL_TEXTURE_2D, texHandle, GR_GL_RGBA8}; // TODO(kjlubick) look at ii for this auto gbt = GrBackendTextures::MakeGL(ii.width, ii.height, skgpu::Mipmapped::kNo, gti); auto dContext = GrAsDirectContext(self.getCanvas()->recordingContext()); return SkImages::BorrowTextureFrom(dContext, gbt, GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin, ii.colorType, ii.alphaType, ii.colorSpace, deleteJSTexture, releaseCtx); })) #endif // CK_ENABLE_WEBGL #ifdef CK_ENABLE_WEBGPU .function("_replaceBackendTexture", optional_override([](SkSurface& self, uint32_t texHandle, uint32_t texFormat, int width, int height) { return ReplaceBackendTexture(self, texHandle, texFormat, width, height); })) #endif // CK_ENABLE_WEBGPU .function("_makeImageSnapshot", optional_override([](SkSurface& self, WASMPointerU32 iPtr)->sk_sp { SkIRect* bounds = reinterpret_cast(iPtr); if (!bounds) { return self.makeImageSnapshot(); } return self.makeImageSnapshot(*bounds); })) .function("_makeSurface", optional_override([](SkSurface& self, SimpleImageInfo sii)->sk_sp { return self.makeSurface(toSkImageInfo(sii)); }), allow_raw_pointers()) #ifdef ENABLE_GPU .function("reportBackendTypeIsGPU", optional_override([](SkSurface& self) -> bool { return self.getCanvas()->recordingContext() != nullptr; })) .function("sampleCnt", optional_override([](SkSurface& self)->int { auto backendRT = SkSurfaces::GetBackendRenderTarget( &self, SkSurfaces::BackendHandleAccess::kFlushRead); return (backendRT.isValid()) ? backendRT.sampleCnt() : 0; })) .function("_resetContext",optional_override([](SkSurface& self)->void { GrAsDirectContext(self.recordingContext())->resetContext(kTextureBinding_GrGLBackendState); })) #else .function("reportBackendTypeIsGPU", optional_override([](SkSurface& self) -> bool { return false; })) #endif .function("width", &SkSurface::width); #ifndef CK_NO_FONTS class_("TextBlob") .smart_ptr>("sk_sp") .class_function("_MakeFromRSXform", optional_override([](WASMPointerU8 sptr, size_t strBtyes, WASMPointerF32 xptr, const SkFont& font)->sk_sp { const char* str = reinterpret_cast(sptr); const SkRSXform* xforms = reinterpret_cast(xptr); return SkTextBlob::MakeFromRSXform(str, strBtyes, xforms, font, SkTextEncoding::kUTF8); }), allow_raw_pointers()) .class_function("_MakeFromRSXformGlyphs", optional_override([](WASMPointerU16 gPtr, size_t byteLen, WASMPointerF32 xptr, const SkFont& font)->sk_sp { const SkGlyphID* glyphs = reinterpret_cast(gPtr); const SkRSXform* xforms = reinterpret_cast(xptr); return SkTextBlob::MakeFromRSXform(glyphs, byteLen, xforms, font, SkTextEncoding::kGlyphID); }), allow_raw_pointers()) .class_function("_MakeFromText", optional_override([](WASMPointerU8 sptr, size_t len, const SkFont& font)->sk_sp { const char* str = reinterpret_cast(sptr); return SkTextBlob::MakeFromText(str, len, font, SkTextEncoding::kUTF8); }), allow_raw_pointers()) .class_function("_MakeFromGlyphs", optional_override([](WASMPointerU16 gPtr, size_t byteLen, const SkFont& font)->sk_sp { const SkGlyphID* glyphs = reinterpret_cast(gPtr); return SkTextBlob::MakeFromText(glyphs, byteLen, font, SkTextEncoding::kGlyphID); }), allow_raw_pointers()); class_("Typeface") .smart_ptr>("sk_sp") .class_function("GetDefault", optional_override([]()->sk_sp { #if defined(CK_EMBED_FONT) if (SK_EMBEDDED_FONTS.count == 0) { return nullptr; } static sk_sp default_face; static SkOnce once; once([] { const SkEmbeddedResource& fontEntry = SK_EMBEDDED_FONTS.entries[0]; auto stream = std::make_unique(fontEntry.data, fontEntry.size, false); default_face = SkTypeface_FreeType::MakeFromStream(std::move(stream), SkFontArguments()); }); return default_face; #else return nullptr; #endif }), allow_raw_pointers()) .class_function("_MakeTypefaceFromData", optional_override([]( WASMPointerU8 fPtr, int flen)->sk_sp { uint8_t* font = reinterpret_cast(fPtr); std::unique_ptr stream(new SkMemoryStream()); stream->setMemoryOwned(font, flen); return SkTypeface_FreeType::MakeFromStream(std::move(stream), SkFontArguments()); }), allow_raw_pointers()) .function("_getGlyphIDs", optional_override([](SkTypeface& self, WASMPointerU8 sptr, size_t strLen, size_t expectedCodePoints, WASMPointerU16 iPtr) -> int { char* str = reinterpret_cast(sptr); SkGlyphID* glyphIDs = reinterpret_cast(iPtr); int actualCodePoints = self.textToGlyphs(str, strLen, SkTextEncoding::kUTF8, glyphIDs, expectedCodePoints); return actualCodePoints; })); #endif class_("Vertices") .smart_ptr>("sk_sp") .function("_bounds", optional_override([](SkVertices& self, WASMPointerF32 fPtr)->void { SkRect* output = reinterpret_cast(fPtr); output[0] = self.bounds(); })) .function("uniqueID", &SkVertices::uniqueID); // Not intended to be called directly by clients class_("_VerticesBuilder") .constructor() .function("colors", optional_override([](SkVertices::Builder& self)->WASMPointerF32{ // Emscripten won't let us return bare pointers, but we can return ints just fine. return reinterpret_cast(self.colors()); })) .function("detach", &SkVertices::Builder::detach) .function("indices", optional_override([](SkVertices::Builder& self)->WASMPointerU16{ // Emscripten won't let us return bare pointers, but we can return ints just fine. return reinterpret_cast(self.indices()); })) .function("positions", optional_override([](SkVertices::Builder& self)->WASMPointerF32{ // Emscripten won't let us return bare pointers, but we can return ints just fine. return reinterpret_cast(self.positions()); })) .function("texCoords", optional_override([](SkVertices::Builder& self)->WASMPointerF32{ // Emscripten won't let us return bare pointers, but we can return ints just fine. return reinterpret_cast(self.texCoords()); })); enum_("AlphaType") .value("Opaque", SkAlphaType::kOpaque_SkAlphaType) .value("Premul", SkAlphaType::kPremul_SkAlphaType) .value("Unpremul", SkAlphaType::kUnpremul_SkAlphaType); enum_("BlendMode") .value("Clear", SkBlendMode::kClear) .value("Src", SkBlendMode::kSrc) .value("Dst", SkBlendMode::kDst) .value("SrcOver", SkBlendMode::kSrcOver) .value("DstOver", SkBlendMode::kDstOver) .value("SrcIn", SkBlendMode::kSrcIn) .value("DstIn", SkBlendMode::kDstIn) .value("SrcOut", SkBlendMode::kSrcOut) .value("DstOut", SkBlendMode::kDstOut) .value("SrcATop", SkBlendMode::kSrcATop) .value("DstATop", SkBlendMode::kDstATop) .value("Xor", SkBlendMode::kXor) .value("Plus", SkBlendMode::kPlus) .value("Modulate", SkBlendMode::kModulate) .value("Screen", SkBlendMode::kScreen) .value("Overlay", SkBlendMode::kOverlay) .value("Darken", SkBlendMode::kDarken) .value("Lighten", SkBlendMode::kLighten) .value("ColorDodge", SkBlendMode::kColorDodge) .value("ColorBurn", SkBlendMode::kColorBurn) .value("HardLight", SkBlendMode::kHardLight) .value("SoftLight", SkBlendMode::kSoftLight) .value("Difference", SkBlendMode::kDifference) .value("Exclusion", SkBlendMode::kExclusion) .value("Multiply", SkBlendMode::kMultiply) .value("Hue", SkBlendMode::kHue) .value("Saturation", SkBlendMode::kSaturation) .value("Color", SkBlendMode::kColor) .value("Luminosity", SkBlendMode::kLuminosity); enum_("BlurStyle") .value("Normal", SkBlurStyle::kNormal_SkBlurStyle) .value("Solid", SkBlurStyle::kSolid_SkBlurStyle) .value("Outer", SkBlurStyle::kOuter_SkBlurStyle) .value("Inner", SkBlurStyle::kInner_SkBlurStyle); enum_("ClipOp") .value("Difference", SkClipOp::kDifference) .value("Intersect", SkClipOp::kIntersect); enum_("ColorChannel") .value("Red", SkColorChannel::kR) .value("Green", SkColorChannel::kG) .value("Blue", SkColorChannel::kB) .value("Alpha", SkColorChannel::kA); enum_("ColorType") .value("Alpha_8", SkColorType::kAlpha_8_SkColorType) .value("RGB_565", SkColorType::kRGB_565_SkColorType) .value("RGBA_8888", SkColorType::kRGBA_8888_SkColorType) .value("BGRA_8888", SkColorType::kBGRA_8888_SkColorType) .value("RGBA_1010102", SkColorType::kRGBA_1010102_SkColorType) .value("RGB_101010x", SkColorType::kRGB_101010x_SkColorType) .value("Gray_8", SkColorType::kGray_8_SkColorType) .value("RGBA_F16", SkColorType::kRGBA_F16_SkColorType) .value("RGBA_F32", SkColorType::kRGBA_F32_SkColorType); enum_("FillType") .value("Winding", SkPathFillType::kWinding) .value("EvenOdd", SkPathFillType::kEvenOdd); enum_("FilterMode") .value("Nearest", SkFilterMode::kNearest) .value("Linear", SkFilterMode::kLinear); // Only used to control the encode function. // TODO(kjlubick): compile these out when the appropriate encoder is disabled. enum_("ImageFormat") .value("PNG", SkEncodedImageFormat::kPNG) .value("JPEG", SkEncodedImageFormat::kJPEG) .value("WEBP", SkEncodedImageFormat::kWEBP); enum_("MipmapMode") .value("None", SkMipmapMode::kNone) .value("Nearest", SkMipmapMode::kNearest) .value("Linear", SkMipmapMode::kLinear); enum_("PaintStyle") .value("Fill", SkPaint::Style::kFill_Style) .value("Stroke", SkPaint::Style::kStroke_Style); enum_("Path1DEffect") .value("Translate", SkPath1DPathEffect::Style::kTranslate_Style) .value("Rotate", SkPath1DPathEffect::Style::kRotate_Style) .value("Morph", SkPath1DPathEffect::Style::kMorph_Style); #ifdef CK_INCLUDE_PATHOPS enum_("PathOp") .value("Difference", SkPathOp::kDifference_SkPathOp) .value("Intersect", SkPathOp::kIntersect_SkPathOp) .value("Union", SkPathOp::kUnion_SkPathOp) .value("XOR", SkPathOp::kXOR_SkPathOp) .value("ReverseDifference", SkPathOp::kReverseDifference_SkPathOp); #endif enum_("PointMode") .value("Points", SkCanvas::PointMode::kPoints_PointMode) .value("Lines", SkCanvas::PointMode::kLines_PointMode) .value("Polygon", SkCanvas::PointMode::kPolygon_PointMode); enum_("StrokeCap") .value("Butt", SkPaint::Cap::kButt_Cap) .value("Round", SkPaint::Cap::kRound_Cap) .value("Square", SkPaint::Cap::kSquare_Cap); enum_("StrokeJoin") .value("Miter", SkPaint::Join::kMiter_Join) .value("Round", SkPaint::Join::kRound_Join) .value("Bevel", SkPaint::Join::kBevel_Join); #ifndef CK_NO_FONTS enum_("FontHinting") .value("None", SkFontHinting::kNone) .value("Slight", SkFontHinting::kSlight) .value("Normal", SkFontHinting::kNormal) .value("Full", SkFontHinting::kFull); enum_("FontEdging") #ifndef CK_NO_ALIAS_FONT .value("Alias", SkFont::Edging::kAlias) #endif .value("AntiAlias", SkFont::Edging::kAntiAlias) .value("SubpixelAntiAlias", SkFont::Edging::kSubpixelAntiAlias); #endif enum_("TileMode") .value("Clamp", SkTileMode::kClamp) .value("Repeat", SkTileMode::kRepeat) .value("Mirror", SkTileMode::kMirror) .value("Decal", SkTileMode::kDecal); enum_("VertexMode") .value("Triangles", SkVertices::VertexMode::kTriangles_VertexMode) .value("TrianglesStrip", SkVertices::VertexMode::kTriangleStrip_VertexMode) .value("TriangleFan", SkVertices::VertexMode::kTriangleFan_VertexMode); // A value object is much simpler than a class - it is returned as a JS // object and does not require delete(). // https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#value-types value_object("ImageInfo") .field("width", &SimpleImageInfo::width) .field("height", &SimpleImageInfo::height) .field("colorType", &SimpleImageInfo::colorType) .field("alphaType", &SimpleImageInfo::alphaType) .field("colorSpace", &SimpleImageInfo::colorSpace); value_object("StrokeOpts") .field("width", &StrokeOpts::width) .field("miter_limit", &StrokeOpts::miter_limit) .field("join", &StrokeOpts::join) .field("cap", &StrokeOpts::cap) .field("precision", &StrokeOpts::precision); constant("MOVE_VERB", MOVE); constant("LINE_VERB", LINE); constant("QUAD_VERB", QUAD); constant("CONIC_VERB", CONIC); constant("CUBIC_VERB", CUBIC); constant("CLOSE_VERB", CLOSE); constant("SaveLayerInitWithPrevious", (int)SkCanvas::SaveLayerFlagsSet::kInitWithPrevious_SaveLayerFlag); constant("SaveLayerF16ColorType", (int)SkCanvas::SaveLayerFlagsSet::kF16ColorType); constant("ShadowTransparentOccluder", (int)SkShadowFlags::kTransparentOccluder_ShadowFlag); constant("ShadowGeometricOnly", (int)SkShadowFlags::kGeometricOnly_ShadowFlag); constant("ShadowDirectionalLight", (int)SkShadowFlags::kDirectionalLight_ShadowFlag); #ifdef CK_INCLUDE_PARAGRAPH constant("_GlyphRunFlags_isWhiteSpace", (int)skia::textlayout::Paragraph::kWhiteSpace_VisitorFlag); #endif }