Lines Matching defs:CanvasKit
1 // Adds JS functions to augment the CanvasKit interface.
5 // CanvasKit.onRuntimeInitialized is called after the WASM library has loaded.
8 CanvasKit.onRuntimeInitialized = function() {
11 _scratchColor = CanvasKit.Malloc(Float32Array, 4); // 4 color scalars.
14 _scratch4x4Matrix = CanvasKit.Malloc(Float32Array, 16); // 16 matrix scalars.
17 _scratch3x3Matrix = CanvasKit.Malloc(Float32Array, 9); // 9 matrix scalars.
20 _scratchRRect = CanvasKit.Malloc(Float32Array, 12); // 4 scalars for rrect, 8 for radii.
23 _scratchRRect2 = CanvasKit.Malloc(Float32Array, 12); // 4 scalars for rrect, 8 for radii.
26 _scratchFourFloatsA = CanvasKit.Malloc(Float32Array, 4);
29 _scratchFourFloatsB = CanvasKit.Malloc(Float32Array, 4);
32 _scratchThreeFloatsA = CanvasKit.Malloc(Float32Array, 3); // 3 floats to represent SkVector3
35 _scratchThreeFloatsB = CanvasKit.Malloc(Float32Array, 3); // 3 floats to represent SkVector3
38 _scratchIRect = CanvasKit.Malloc(Int32Array, 4);
43 CanvasKit.ColorSpace.SRGB = CanvasKit.ColorSpace._MakeSRGB();
44 CanvasKit.ColorSpace.DISPLAY_P3 = CanvasKit.ColorSpace._MakeDisplayP3();
45 CanvasKit.ColorSpace.ADOBE_RGB = CanvasKit.ColorSpace._MakeAdobeRGB();
48 CanvasKit['GlyphRunFlags'] = {
49 'IsWhiteSpace': CanvasKit['_GlyphRunFlags_isWhiteSpace'],
52 CanvasKit.Path.MakeFromCmds = function(cmds) {
54 var path = CanvasKit.Path._MakeFromCmds(cmdPtr, cmds.length);
60 CanvasKit.Path.MakeFromVerbsPointsWeights = function(verbs, pts, weights) {
65 var path = CanvasKit.Path._MakeFromVerbsPointsWeights(
73 CanvasKit.Path.prototype.addArc = function(oval, startAngle, sweepAngle) {
81 CanvasKit.Path.prototype.addOval = function(oval, isCCW, startIndex) {
91 CanvasKit.Path.prototype.addPath = function() {
136 CanvasKit.Path.prototype.addPoly = function(points, close) {
143 CanvasKit.Path.prototype.addRect = function(rect, isCCW) {
149 CanvasKit.Path.prototype.addRRect = function(rrect, isCCW) {
156 CanvasKit.Path.prototype.addVerbsPointsWeights = function(verbs, points, weights) {
168 CanvasKit.Path.prototype.arc = function(x, y, radius, startAngle, endAngle, ccw) {
171 var bounds = CanvasKit.LTRBRect(x-radius, y-radius, x+radius, y+radius);
173 var temp = new CanvasKit.Path();
184 CanvasKit.Path.prototype.arcToOval = function(oval, startAngle, sweepAngle, forceMoveTo) {
204 CanvasKit.Path.prototype.arcToRotated = function(rx, ry, xAxisRotate, useSmallArc, isCCW, x, y) {
222 CanvasKit.Path.prototype.arcToTangent = function(x1, y1, x2, y2, radius) {
227 CanvasKit.Path.prototype.close = function() {
232 CanvasKit.Path.prototype.conicTo = function(x1, y1, x2, y2, w) {
240 CanvasKit.Path.prototype.computeTightBounds = function(optionalOutputArray) {
250 CanvasKit.Path.prototype.cubicTo = function(cp1x, cp1y, cp2x, cp2y, x, y) {
255 CanvasKit.Path.prototype.dash = function(on, off, phase) {
265 CanvasKit.Path.prototype.getBounds = function(optionalOutputArray) {
275 CanvasKit.Path.prototype.lineTo = function(x, y) {
280 CanvasKit.Path.prototype.moveTo = function(x, y) {
285 CanvasKit.Path.prototype.offset = function(dx, dy) {
292 CanvasKit.Path.prototype.quadTo = function(cpx, cpy, x, y) {
297 CanvasKit.Path.prototype.rArcTo = function(rx, ry, xAxisRotate, useSmallArc, isCCW, dx, dy) {
302 CanvasKit.Path.prototype.rConicTo = function(dx1, dy1, dx2, dy2, w) {
308 CanvasKit.Path.prototype.rCubicTo = function(cp1x, cp1y, cp2x, cp2y, x, y) {
313 CanvasKit.Path.prototype.rLineTo = function(dx, dy) {
318 CanvasKit.Path.prototype.rMoveTo = function(dx, dy) {
324 CanvasKit.Path.prototype.rQuadTo = function(cpx, cpy, x, y) {
329 CanvasKit.Path.prototype.stroke = function(opts) {
334 opts['cap'] = opts['cap'] || CanvasKit.StrokeCap.Butt;
335 opts['join'] = opts['join'] || CanvasKit.StrokeJoin.Miter;
344 CanvasKit.Path.prototype.transform = function() {
364 CanvasKit.Path.prototype.trim = function(startT, stopT, isComplement) {
375 CanvasKit.Image.prototype.makeShaderCubic = function(xTileMode, yTileMode,
386 CanvasKit.Image.prototype.makeShaderOptions = function(xTileMode, yTileMode,
396 if (imageInfo['colorType'] === CanvasKit.ColorType.RGBA_F16) {
399 else if (imageInfo['colorType'] === CanvasKit.ColorType.RGBA_F32) {
408 pPtr = CanvasKit._malloc(pBytes);
414 CanvasKit._free(pPtr);
428 case CanvasKit.ColorType.RGBA_8888:
429 case CanvasKit.ColorType.RGBA_F16: // there is no half-float JS type, so we return raw bytes.
430 retVal = new Uint8Array(CanvasKit.HEAPU8.buffer, pPtr, pBytes).slice();
432 case CanvasKit.ColorType.RGBA_F32:
433 retVal = new Float32Array(CanvasKit.HEAPU8.buffer, pPtr, pBytes).slice();
441 CanvasKit._free(pPtr);
445 CanvasKit.Image.prototype.readPixels = function(srcX, srcY, imageInfo, destMallocObj,
451 CanvasKit.Canvas.prototype.clear = function(color4f) {
452 CanvasKit.setCurrentContext(this._context);
457 CanvasKit.Canvas.prototype.clipRRect = function(rrect, op, antialias) {
458 CanvasKit.setCurrentContext(this._context);
463 CanvasKit.Canvas.prototype.clipRect = function(rect, op, antialias) {
464 CanvasKit.setCurrentContext(this._context);
471 CanvasKit.Canvas.prototype.concat = function(matr) {
472 CanvasKit.setCurrentContext(this._context);
477 CanvasKit.Canvas.prototype.drawArc = function(oval, startAngle, sweepAngle, useCenter, paint) {
478 CanvasKit.setCurrentContext(this._context);
483 // atlas is an Image, e.g. from CanvasKit.MakeImageFromEncoded
487 CanvasKit.Canvas.prototype.drawAtlas = function(atlas, srcRects, dstXforms, paint,
503 CanvasKit.setCurrentContext(this._context);
505 blendMode = CanvasKit.BlendMode.SrcOver;
526 let filter = CanvasKit.FilterMode.Linear;
527 let mipmap = CanvasKit.MipmapMode.None;
543 CanvasKit.Canvas.prototype.drawCircle = function(cx, cy, r, paint) {
544 CanvasKit.setCurrentContext(this._context);
548 CanvasKit.Canvas.prototype.drawColor = function(color4f, mode) {
549 CanvasKit.setCurrentContext(this._context);
558 CanvasKit.Canvas.prototype.drawColorInt = function(color, mode) {
559 CanvasKit.setCurrentContext(this._context);
560 this._drawColorInt(color, mode || CanvasKit.BlendMode.SrcOver);
563 CanvasKit.Canvas.prototype.drawColorComponents = function(r, g, b, a, mode) {
564 CanvasKit.setCurrentContext(this._context);
573 CanvasKit.Canvas.prototype.drawDRRect = function(outer, inner, paint) {
574 CanvasKit.setCurrentContext(this._context);
580 CanvasKit.Canvas.prototype.drawGlyphs = function(glyphs, positions, x, y, font, paint) {
584 CanvasKit.setCurrentContext(this._context);
594 CanvasKit.Canvas.prototype.drawImage = function(img, x, y, paint) {
595 CanvasKit.setCurrentContext(this._context);
599 CanvasKit.Canvas.prototype.drawImageCubic = function(img, x, y, b, c, paint) {
600 CanvasKit.setCurrentContext(this._context);
604 CanvasKit.Canvas.prototype.drawImageOptions = function(img, x, y, filter, mipmap, paint) {
605 CanvasKit.setCurrentContext(this._context);
609 CanvasKit.Canvas.prototype.drawImageNine = function(img, center, dest, filter, paint) {
610 CanvasKit.setCurrentContext(this._context);
616 CanvasKit.Canvas.prototype.drawImageRect = function(img, src, dest, paint, fastSample) {
617 CanvasKit.setCurrentContext(this._context);
623 CanvasKit.Canvas.prototype.drawImageRectCubic = function(img, src, dest, B, C, paint) {
624 CanvasKit.setCurrentContext(this._context);
631 CanvasKit.Canvas.prototype.drawImageRectOptions = function(img, src, dest, filter, mipmap, paint) {
632 CanvasKit.setCurrentContext(this._context);
639 CanvasKit.Canvas.prototype.drawLine = function(x1, y1, x2, y2, paint) {
640 CanvasKit.setCurrentContext(this._context);
644 CanvasKit.Canvas.prototype.drawOval = function(oval, paint) {
645 CanvasKit.setCurrentContext(this._context);
650 CanvasKit.Canvas.prototype.drawPaint = function(paint) {
651 CanvasKit.setCurrentContext(this._context);
655 CanvasKit.Canvas.prototype.drawParagraph = function(p, x, y) {
656 CanvasKit.setCurrentContext(this._context);
660 CanvasKit.Canvas.prototype.drawPatch = function(cubics, colors, texs, mode, paint) {
670 CanvasKit.setCurrentContext(this._context);
676 mode = CanvasKit.BlendMode.Modulate;
686 CanvasKit.Canvas.prototype.drawPath = function(path, paint) {
687 CanvasKit.setCurrentContext(this._context);
691 CanvasKit.Canvas.prototype.drawPicture = function(pic) {
692 CanvasKit.setCurrentContext(this._context);
699 CanvasKit.Canvas.prototype.drawPoints = function(mode, points, paint) {
700 CanvasKit.setCurrentContext(this._context);
706 CanvasKit.Canvas.prototype.drawRRect = function(rrect, paint) {
707 CanvasKit.setCurrentContext(this._context);
712 CanvasKit.Canvas.prototype.drawRect = function(rect, paint) {
713 CanvasKit.setCurrentContext(this._context);
718 CanvasKit.Canvas.prototype.drawRect4f = function(l, t, r, b, paint) {
719 CanvasKit.setCurrentContext(this._context);
723 CanvasKit.Canvas.prototype.drawShadow = function(path, zPlaneParams, lightPos, lightRadius,
725 CanvasKit.setCurrentContext(this._context);
736 CanvasKit.getShadowLocalBounds = function(ctm, path, zPlaneParams, lightPos, lightRadius,
755 CanvasKit.Canvas.prototype.drawTextBlob = function(blob, x, y, paint) {
756 CanvasKit.setCurrentContext(this._context);
760 CanvasKit.Canvas.prototype.drawVertices = function(verts, mode, paint) {
761 CanvasKit.setCurrentContext(this._context);
766 CanvasKit.Canvas.prototype.getLocalToDevice = function() {
774 CanvasKit.Canvas.prototype.findMarkedCTM = function(marker) {
784 CanvasKit.Canvas.prototype.getTotalMatrix = function() {
791 rv[i] = CanvasKit.HEAPF32[_scratch3x3MatrixPtr/4 + i]; // divide by 4 to "cast" to float.
796 CanvasKit.Canvas.prototype.makeSurface = function(imageInfo) {
802 CanvasKit.Canvas.prototype.readPixels = function(srcX, srcY, imageInfo, destMallocObj,
804 CanvasKit.setCurrentContext(this._context);
808 CanvasKit.Canvas.prototype.saveLayer = function(paint, boundsRect, backdrop, flags) {
816 CanvasKit.Canvas.prototype.writePixels = function(pixels, srcWidth, srcHeight,
821 CanvasKit.setCurrentContext(this._context);
824 alphaType = alphaType || CanvasKit.AlphaType.Unpremul;
825 colorType = colorType || CanvasKit.ColorType.RGBA_8888;
826 colorSpace = colorSpace || CanvasKit.ColorSpace.SRGB;
842 CanvasKit.ColorFilter.MakeBlend = function(color4f, mode) {
844 return CanvasKit.ColorFilter._MakeBlend(cPtr, mode);
848 CanvasKit.ColorFilter.MakeMatrix = function(colorMatrix) {
854 var m = CanvasKit.ColorFilter._makeMatrix(fptr);
859 CanvasKit.ContourMeasure.prototype.getPosTan = function(distance, optionalOutput) {
869 CanvasKit.ImageFilter.MakeMatrixTransform = function(matrix, sampling, input) {
873 return CanvasKit.ImageFilter._MakeMatrixTransformCubic(matrPtr,
878 let mipmap = CanvasKit.MipmapMode.None;
882 return CanvasKit.ImageFilter._MakeMatrixTransformOptions(matrPtr,
888 CanvasKit.Paint.prototype.getColor = function() {
893 CanvasKit.Paint.prototype.setColor = function(color4f, colorSpace) {
903 CanvasKit.Paint.prototype.setColorComponents = function(r, g, b, a, colorSpace) {
910 CanvasKit.Path.prototype.getPoint = function(idx, optionalOutput) {
925 CanvasKit.PictureRecorder.prototype.beginRecording = function(bounds) {
930 CanvasKit.Surface.prototype.getCanvas = function() {
936 CanvasKit.Surface.prototype.makeImageSnapshot = function(optionalBoundsRect) {
937 CanvasKit.setCurrentContext(this._context);
942 CanvasKit.Surface.prototype.makeSurface = function(imageInfo) {
943 CanvasKit.setCurrentContext(this._context);
949 CanvasKit.Surface.prototype.requestAnimationFrame = function(callback, dirtyRect) {
954 CanvasKit.setCurrentContext(this._context);
967 CanvasKit.Surface.prototype.drawOnce = function(callback, dirtyRect) {
972 CanvasKit.setCurrentContext(this._context);
980 CanvasKit.PathEffect.MakeDash = function(intervals, phase) {
988 var dpe = CanvasKit.PathEffect._MakeDash(ptr, intervals.length, phase);
993 CanvasKit.Shader.MakeColor = function(color4f, colorSpace) {
996 return CanvasKit.Shader._MakeColor(cPtr, colorSpace);
1000 CanvasKit.Shader.Blend = CanvasKit.Shader.MakeBlend;
1001 CanvasKit.Shader.Color = CanvasKit.Shader.MakeColor;
1003 CanvasKit.Shader.MakeLinearGradient = function(start, end, colors, pos, mode, localMatrix, flags, colorSpace) {
1015 var lgs = CanvasKit.Shader._MakeLinearGradient(_scratchFourFloatsAPtr, cPtrInfo.colorPtr, cPtrInfo.colorType, posPtr,
1023 CanvasKit.Shader.MakeRadialGradient = function(center, radius, colors, pos, mode, localMatrix, flags, colorSpace) {
1030 var rgs = CanvasKit.Shader._MakeRadialGradient(center[0], center[1], radius, cPtrInfo.colorPtr,
1039 CanvasKit.Shader.MakeSweepGradient = function(cx, cy, colors, pos, mode, localMatrix, flags, startAngle, endAngle, colorSpace) {
1048 var sgs = CanvasKit.Shader._MakeSweepGradient(cx, cy, cPtrInfo.colorPtr, cPtrInfo.colorType, posPtr,
1058 CanvasKit.Shader.MakeTwoPointConicalGradient = function(start, startRadius, end, endRadius,
1071 var rgs = CanvasKit.Shader._MakeTwoPointConicalGradient(_scratchFourFloatsAPtr,
1083 CanvasKit.Vertices.prototype.bounds = function(optionalOutputArray) {
1094 if (CanvasKit._extraInitializations) {
1095 CanvasKit._extraInitializations.forEach(function(init) {
1099 }; // end CanvasKit.onRuntimeInitialized, that is, anything changing prototypes or dynamic.
1109 CanvasKit.computeTonalColors = function(tonalColors) {
1126 CanvasKit.LTRBRect = function(l, t, r, b) {
1130 CanvasKit.XYWHRect = function(x, y, w, h) {
1134 CanvasKit.LTRBiRect = function(l, t, r, b) {
1138 CanvasKit.XYWHiRect = function(x, y, w, h) {
1144 CanvasKit.RRectXY = function(rect, rx, ry) {
1155 CanvasKit.MakeAnimatedImageFromEncoded = function(data) {
1158 var iptr = CanvasKit._malloc(data.byteLength);
1159 CanvasKit.HEAPU8.set(data, iptr);
1160 var img = CanvasKit._decodeAnimatedImage(iptr, data.byteLength);
1169 CanvasKit.MakeImageFromEncoded = function(data) {
1172 var iptr = CanvasKit._malloc(data.byteLength);
1173 CanvasKit.HEAPU8.set(data, iptr);
1174 var img = CanvasKit._decodeImage(iptr, data.byteLength);
1185 // Alternative to CanvasKit.MakeImageFromEncoded. Allows for CanvasKit users to take advantage of
1186 // browser APIs to decode images instead of using codecs included in the CanvasKit wasm binary.
1189 CanvasKit.MakeImageFromCanvasImageSource = function(canvasImageSource) {
1204 return CanvasKit.MakeImage({
1207 'alphaType': CanvasKit.AlphaType.Unpremul,
1208 'colorType': CanvasKit.ColorType.RGBA_8888,
1209 'colorSpace': CanvasKit.ColorSpace.SRGB
1216 CanvasKit.MakeImage = function(info, pixels, bytesPerRow) {
1217 var pptr = CanvasKit._malloc(pixels.length);
1218 CanvasKit.HEAPU8.set(pixels, pptr); // We always want to copy the bytes into the WASM heap.
1220 return CanvasKit._MakeImage(info, pptr, pixels.length, bytesPerRow);
1227 CanvasKit.MakeVertices = function(mode, positions, textureCoordinates, colors,
1245 var builder = new CanvasKit._VerticesBuilder(mode, positions.length / 2, idxCount, flags);